packages feed

hmatrix (empty) → 0.1.0.0

raw patch · 112 files changed

+17142/−0 lines, 112 filesdep +arraydep +basedep +haskell98build-type:Customsetup-changed

Dependencies added: array, base, haskell98

Files

+ LICENSE view
@@ -0,0 +1,2 @@+Copyright Alberto Ruiz 2006-2007+GPL license
+ README view
@@ -0,0 +1,170 @@+A simple scientific library for Haskell+---------------------------------------++REQUIREMENTS++Development packages of:++1) GNU Scientific Library (http://www.gnu.org/software/gsl)++2) BLAS and LAPACK (http://www.netlib.org/lapack)++3) ATLAS (recommended) (http://math-atlas.sourceforge.net/)++For example, in Ubuntu Linux we need:++- libgsl0-dev+- refblas3-dev+- lapack3-dev+- atlas3-base-dev++You can also install an atlas version specifically tuned+for your machine (but see the TESTS section below).++The following packages are used for simple graphics:++- gnuplot+- imagemagick++GNU-Octave can be used to check if the results+obtained by this library are correct.++INSTALLATION++$ runhaskell Setup.lhs configure --prefix=$HOME+$ runhaskell Setup.lhs build+$ runhaskell Setup.lhs haddock+$ runhaskell Setup.lhs install --user++See below for installation on Windows.++For undetermined reasons compilation with -O in Linux requires -fvia-C.++TESTS++$ runhaskell examples/tests++Additional tests with big matrices (taking a few minutes):++$ runhaskell examples/tests --big++NOTE: On Ubuntu 6.06 LTS (Dapper) atlas3-sse2-dev (3.6.0-20)+produces segmentation faults when working with big matrices +on compiled programs. To expose the problem:++$ cd examples+$ ghc --make -O -fvia-C tests.hs+$ ./tests --big++If this crashes, just uninstall atlas3-sse2 and use atlas3-base-dev instead.+Fortunately, atlas3-sse2-dev seems to work well on Ubuntu 7.10 Gutsy.+A similar problem was reported at:+    http://article.gmane.org/gmane.linux.debian.devel.bugs.general/323065++EXAMPLES++$ ghci+Prelude> :m + Numeric.GSL+Prelude Numeric.GSL> let quad = integrateQNG 1E-10+Prelude Numeric.GSL> quad (^2) 0 1+(0.3333333333333333,3.700743415417188e-15)++Prelude Numeric.GSL> :m + Numeric.LinearAlgebra+Prelude Numeric.LinearAlgebra> let m = (2><3)[1,2,3,4,5,6::Double]+Prelude Numeric.LinearAlgebra> let (u,d,v) = full svd m+Prelude Numeric.LinearAlgebra> d+(2><3)+ [ 9.508032000695724,                0.0, 0.0+ ,               0.0, 0.7728696356734838, 0.0 ]+Prelude Numeric.LinearAlgebra> u <> d <> trans v+(2><3)+ [ 1.0000000000000004,               2.0, 3.0+ , 3.9999999999999996, 5.000000000000001, 6.0 ]+Prelude Numeric.GSL> :q+Leaving GHCi.++A number of illustrative programs are included in the examples folder.++CHANGES++This is a new version of the library previously known as GSLHaskell.+It has been renamed to "hmatrix" because only a small part of GSL is actually+available, and most linear algebra is based on LAPACK.++The code has been extensively refactored. There is a new internal representation+which admits both C and Fortran matrices and avoids many transposes.++There are only minor API changes:++- The matrix product operator (<>) is now overloaded only for matrix-matrix,+  matrix-vector and vector-matrix, with the same base type. Dot product and scaling+  of vectors or matrices is now denoted by `dot` or (<.>) and `scale` or (.*).+  Conversions from real to complex objects must now be explicit.++- Most linear algebra functions admit both real and complex objects. Utilities such as+  ident or constant are now polymorphic.++- Runtime errors produced by GSL or LAPACK can be handled using Control.Exeception.catch.++Old GSLHaskell code will work with small modifications.++INSTALLATION ON WINDOWS++1) Download the developer files gsl-1.8-lib.zip from+   http://gnuwin32.sourceforge.net/packages/gsl.htm+   and copy the gsl headers folder (under include) to:+       C:\ghc\ghc.6.x.1\include+   These headers are also available from:+       http://perception.inf.um.es/~aruiz/darcs/hmatrix/gsl.zip++2) Install the package as usual:+       runhaskell Setup.lhs configure+       runhaskell Setup.lhs build+       runhaskell Setup.lhs install++2.5) If configure cannot find ld please see:+       http://article.gmane.org/gmane.comp.lang.haskell.cafe/32025++3) Copy libgsl.dll, libcblas.dll (from the binaries package gsl-1.8.bin.zip)+   and liblapack.dll (borrowed from the R system) to the folder in which+   hmatrix has been installed: C:\Program Files\haskell\hmatrix-x.x.x.x\ghc-6.x.x.+   Rename libcblas.dll to libblas.dll.+   They are needed to compile programs.+   These three dlls are available from:+       http://perception.inf.um.es/~aruiz/darcs/hmatrix/dll1.zip++4) Copy the dlls available from:+       http://perception.inf.um.es/~aruiz/darcs/hmatrix/dll2.zip+   to the working directory or C:\windows\system+   They are required to run the programs and ghci.++5) run the tests++Unfortunately the lapack dll supplied by the R system does not include+zgels_, zgelss_, and zgees_, so the functions depending on them+(linearSolveLS, linearSolveSVD, and schur for complex data)+will produce a "non supported in this OS" runtime error.++If you find an alternative free and complete lapack.dll which works well+for this system please let me know.++The examples using graphics do not yet work in windows.++ACKNOWLEDGEMENTS++I thank Henning Thielemann and all the people in the Haskell mailing lists for their help.++- Nico Mahlo discovered a bug in the eigendecomposition wrapper.++- Frederik Eaton discovered a bug in the design of the wrappers.++- Eric Kidd has created a wiki page explaining the installation on MacOS X:+  http://www.haskell.org/haskellwiki/GSLHaskell_on_MacOS_X++- Fawzi Mohamed discovered a portability bug in the lapack wrappers.++- Pedro E. López de Teruel fixed the interface to lapack.++- Antti Siira discovered a bug in the plotting functions.++- Paulo Tanimoto helped to fix the configuration of the required libraries.
+ Setup.lhs view
@@ -0,0 +1,4 @@+#! /usr/bin/env runhaskell++> import Distribution.Simple+> main = defaultMain
+ examples/data.txt view
@@ -0,0 +1,10 @@+ 0.9    1.1+ 2.1    3.9+ 3.1    9.2+ 4.0   51.8+ 4.9   25.3+ 6.1   35.7+ 7.0   49.4+ 7.9    3.6+ 9.1   81.5+10.2   99.5
+ examples/deriv.hs view
@@ -0,0 +1,8 @@+-- Numerical differentiation++import Numeric.GSL++d :: (Double -> Double) -> (Double -> Double)+d f x = fst $ derivCentral 0.01 f x++main = print $ d (\x-> x * d (\y-> x+y) 1) 1
+ examples/experiments/Static.hs view
@@ -0,0 +1,123 @@+{-# OPTIONS_GHC -fglasgow-exts -fth -fallow-overlapping-instances -fallow-undecidable-instances #-}++module Static where++import Language.Haskell.TH+import Numeric.LinearAlgebra+import Foreign+import Language.Haskell.TH.Syntax+import Data.Packed.Internal(Vector(..),Matrix(..))++instance Lift Double where+  lift x = return (LitE (RationalL (toRational x)))++instance Lift (Ptr Double) where+    lift p = [e| p |]++instance Lift (ForeignPtr Double) where+    lift p = [e| p |]++instance (Lift a, Storable a, Lift (Ptr a), Lift (ForeignPtr a)) => Lift (Vector a ) where+    lift (V n fp) = [e| V $(lift n) $(lift fp) |]++instance (Lift (Vector a)) => Lift (Matrix a) where+    lift (MC r c v) = [e| MC $(lift r) $(lift c) $(lift v) |]+    lift (MF r c v) = [e| MF $(lift r) $(lift c) $(lift v) |]++tdim :: Int -> ExpQ+tdim 0 = [| Z |]+tdim n = [| S $(tdim (n-1)) |]+++data Z = Z deriving Show+data S a = S a deriving Show++class Dim a++instance Dim Z+instance Dim a => Dim (S a)++class Sum a b c | a b -> c -- , a c -> b, b c -> a++instance Sum Z a a+instance Sum a Z a+instance Sum a b c => Sum a (S b) (S c)++newtype SVec d t = SVec (Vector t) deriving Show+newtype SMat r c t = SMat (Matrix t) deriving Show++createl :: d -> [Double] -> SVec d Double+createl d l = SVec (fromList l)++createv :: Storable t => d -> Vector t -> SVec d t+createv d v = SVec v++--vec'' v = [|createv ($(tdim (dim v))) v|]++vec' :: [Double] -> ExpQ+vec' d = [| createl ($(tdim (length d))) d |]+++createm :: (Dim r, Dim c) => r -> c -> (Matrix Double) -> SMat r c Double+createm _ _ m = SMat m++createml :: (Dim r, Dim c) => r -> c -> Int -> Int -> [Double] -> SMat r c Double+createml _ _ r c l = SMat ((r><c) l)++mat :: Int -> Int -> [Double] -> ExpQ+mat r c l = [| createml ($(tdim r)) ($(tdim c)) r c l |]++vec :: [Double] -> ExpQ+vec d = mat (length d) 1 d+++mat' :: Matrix Double -> ExpQ+mat' m = [| createm ($(tdim (rows m))) ($(tdim (cols m))) m |]++covec :: [Double] -> ExpQ+covec d = mat 1 (length d) d++scalar :: SMat (S Z) (S Z) Double -> Double+scalar (SMat m) = flatten m @> 0++v = fromList [1..5] :: Vector Double+l = [1,1.5..5::Double]++k = [11..30::Int]++rawv (SVec v) = v+raw (SMat m) = m++liftStatic :: (Matrix a -> Matrix b -> Matrix c) -> SMat dr dc a -> SMat dr dc b -> SMat dr dc c+liftStatic f a b = SMat (f (raw a) (raw b))++a |+| b = liftStatic (+) a b++prod :: SMat r k Double -> SMat k c Double -> SMat r c Double+prod a b = SMat (raw a <> raw b)++strans :: SMat r c Double -> SMat c r Double+strans = SMat . trans . raw++sdot a b = scalar (prod a b)++jv :: (Field t, Sum r1 r2 r3) => SMat r1 c t -> SMat r2 c t -> SMat r3 c t+jv a b = SMat ((raw a) <-> (raw b))++-- curiously, we cannot easily fold jv because the matrics are not of the same type.++jh a b = strans (jv (strans a) (strans b))+++homog :: (Field t) => SMat r c t -> SMat (S r) c t+homog m = SMat (raw m <-> constant 1 (cols (raw m)))++inhomog :: (Linear Vector t) => SMat (S (S r)) c t -> SMat r c t+inhomog (SMat m) = SMat (sm <> d) where+    sm = takeRows r' m+    d = diag $ 1 / (flatten $ dropRows r' m)+    r' = rows m -1+++ht t vs = inhomog (t `prod` homog vs)+
+ examples/experiments/error.hs view
@@ -0,0 +1,16 @@+import Numeric.GSL+import Prelude hiding (catch)+import Control.Exception++test x = catch+       (print x)+       (\e -> putStrLn $ "captured ["++ show e++"]")++main = do+    setErrorHandlerOff++    test $ log_e (-1)+    test $ 5 + (fst.exp_e) 1000+    test $ bessel_zero_Jnu_e (-0.3) 2++    putStrLn "Bye"
+ examples/experiments/listlike.hs view
@@ -0,0 +1,32 @@+{-# OPTIONS_GHC -fglasgow-exts #-}++import qualified Data.ListLike as LL+import Numeric.LinearAlgebra+import Data.Monoid+import Data.Packed.Internal.Vector+import Foreign++instance (Storable a) => Monoid (Vector a) where+    mempty = V { dim = 0, fptr = undefined, ptr = undefined }+    mappend a b = mconcat [a,b]+    mconcat = j . filter ((>0).dim)+        where j [] = mempty+              j l  = join l++instance Storable a => LL.FoldableLL (Vector a) a where+    foldl f x v = foldl f x (toList v)+    foldr f x v = foldr f x (toList v)++instance Storable a => LL.ListLike (Vector a) a where+    singleton a = fromList [a]+    head a = a @> 0+    tail a | dim a == 1 = mempty+           | otherwise  = subVector 1 (dim a -1) a+    genericLength = fromIntegral.dim+++v k = fromList [1..k] :: Vector Double++f k = k+(3::Double)++main = print $ (LL.map f [1..5] :: Vector Double)
+ examples/experiments/parallel.hs view
@@ -0,0 +1,28 @@+import System(getArgs)+import Numeric.LinearAlgebra+import Control.Parallel.Strategies+import System.Time++inParallel = parMap rwhnf id++parMul x y = fromBlocks [inParallel[x <> y1, x <> y2]]+    where p = cols y `div` 2+          (y1,y2) = splitColumnsAt p y++main = do+    n <- (read . head) `fmap` getArgs+    let m = ident n :: Matrix Double+    time $ print $ vectorMax $ takeDiag $ parMul m m+    time $ print $ vectorMax $ takeDiag $ m <> m++a = (2><3) [1..6::Double]+b = (3><4) [1..12::Double]++splitRowsAt p m    = (takeRows p m, dropRows p m)+splitColumnsAt p m = (takeColumns p m, dropColumns p m)++time act = do+    t0 <- getClockTime+    act+    t1 <- getClockTime+    print $ tdSec $ normalizeTimeDiff $ diffClockTimes t1 t0
+ examples/experiments/speed.hs view
@@ -0,0 +1,90 @@+{- speed tests++GNU-Octave (see speed.m in this folder):++./speed.m+  -0.017877255967426   0.000000000000000  -0.999840189089781+   0.000000000000000   1.000000000000000   0.000000000000000+   0.999840189089763   0.000000000000000  -0.017877255967417+9.69 seconds++Mathematica:++rot[a_]:={{ Cos[a], 0, Sin[a]},+          { 0,      1,      0},+          { -Sin[a],0,Cos[a]}}//N++test := Timing[+    n = 100000;+    angles = Range[0.,n-1]/(n-1);+    Fold[Dot,IdentityMatrix[3],rot/@angles] // MatrixForm+]++2.08013 Second+     {{\(-0.017877255967432837`\), "0.`", \(-0.9998401890898042`\)},+      {"0.`", "1.`", "0.`"},+      {"0.9998401890898042`", "0.`", \(-0.017877255967432837`\)}}++$ ghc --make -O speed++$ ./speed 5 100000 1+(3><3)+ [ -1.7877255967425523e-2, 0.0,    -0.9998401890897632+ ,                    0.0, 1.0,                    0.0+ ,      0.999840189089781, 0.0, -1.7877255967416586e-2 ]+0.33 CPU seconds++cos 50000 = -0.0178772559665563+sin 50000 = -0.999840189089790++-}++import Numeric.LinearAlgebra+import System+import Data.List(foldl1')+import System.CPUTime+import Text.Printf+import Debug.Trace++debug x = trace (show x) x++timing act = do+    t0 <- getCPUTime+    act+    t1 <- getCPUTime+    printf "%.2f CPU seconds\n" $ (fromIntegral ((t1 - t0) `div` (10^10)) / 100 :: Double) :: IO ()++op a b = trans $ (trans a) <> (trans b)++op2 a b = trans $ (trans a) + (trans b)++rot' :: Double -> Matrix Double+rot' a = matrix [[ c,0,s],+                 [ 0,1,0],+                 [-s,0,c]]+    where c = cos a+          s = sin a+          matrix = fromLists++rot :: Double -> Matrix Double+rot a = (3><3) [ c,0,s+               , 0,1,0+               ,-s,0,c ]+    where c = cos a+          s = sin a++fun n r = foldl1' (<>) (map r angles)+    where angles = toList $ linspace n (0,1)++main = do+    args <- getArgs+    let [p,n,d] = map read args+    let ms = replicate n ((ident d :: Matrix Double))+    let mz = replicate n (diag (constant (0::Double) d))+    timing $ case p of+        0 -> print $ foldl1' (<>) ms+        1 -> print $ foldl1' (<>) (map trans ms)+        2 -> print $ foldl1' op ms+        3 -> print $ foldl1' op2 mz+        4 -> print $ fun n rot'+        5 -> print $ fun n rot
+ examples/experiments/speed.m view
@@ -0,0 +1,21 @@+#! /usr/bin/octave -qf+1; % measuring Octave computing times++function r = rot(a)+    c = cos(a);+    s = sin(a);+    r = [ c , 0, s;+          0,  1, 0;+         -s,  0, c];+end++t0=time();+x = linspace(0,1,1E5);+ac = eye(3);+for a = x+    ac = ac*rot(a);+end++format long+disp(ac);+printf("%.2f seconds\n",time()-t0)
+ examples/experiments/testmnist.m view
@@ -0,0 +1,29 @@+#! /usr/bin/octave -qf+% measuring Octave computing times++t0=time();+load mnist.txt+disp("load");+disp(time()-t0)+++x = mnist(:,1:784);+d = mnist(:,785);+++t0=time();+xc = x - repmat(mean(x),rows(x),1);+disp("x - repmat(mean(x),rows(x),1)");+disp(time()-t0)++t0=time();+mc = (xc'*xc)/rows(x);+disp("(xc'*xc)/rows(x)");+disp(time()-t0)++t0=time();+[v,l]=eig(mc);+disp("eig");+disp(time()-t0)++disp(flipud(diag(l))(1:10));
+ examples/experiments/useStatic.hs view
@@ -0,0 +1,36 @@+{-# OPTIONS -fno-monomorphism-restriction #-}++import Static+import Numeric.LinearAlgebra+++x = $(vec [1,2])++y = $(vec [5,7])++z a = vec [a,a]++w = $(vec [1,2,3])++cx = $(covec [1,2,3])+++t3 = $(tdim 3)++crm33 = createml t3 t3 3 3++rot a = crm33 [a,0,0,0,a,0,0,0,1]++--q = x |+| y |+| $(z 5)++m = $(mat 2 3 [1..6])++n = $(mat 3 5 [1..15])++infixl 7 <*>+(<*>) = prod++r1 = m <*> n+r2 = strans (strans n <*> strans m)++--r' = prod n m
+ examples/integrate.hs view
@@ -0,0 +1,17 @@+-- Numerical integration+import Numeric.GSL++quad f a b = fst $ integrateQAGS 1E-9 100 f a b  ++-- A multiple integral can be easily defined using partial application+quad2 f a b g1 g2 = quad h a b+    where h x = quad (f x) (g1 x) (g2 x)++volSphere r = 8 * quad2 (\x y -> sqrt (r*r-x*x-y*y)) +                        0 r (const 0) (\x->sqrt (r*r-x*x))++main = do+    print $ quad (\x -> 4/(x^2+1)) 0 1+    print pi+    print $ volSphere 2.5+    print $ 4/3*pi*2.5**3
+ examples/kalman.hs view
@@ -0,0 +1,53 @@+import Numeric.LinearAlgebra+import Graphics.Plot++vector l = fromList l :: Vector Double+matrix ls = fromLists ls :: Matrix Double+diagl = diag . vector++f = matrix [[1,0,0,0],+            [1,1,0,0],+            [0,0,1,0],+            [0,0,0,1]]++h = matrix [[0,-1,1,0],+            [0,-1,0,1]]++q = diagl [1,1,0,0]++r = diagl [2,2]++s0 = State (vector [0, 0, 10, -10]) (diagl [10,0, 100, 100])++data System = System {kF, kH, kQ, kR :: Matrix Double}+data State = State {sX :: Vector Double , sP :: Matrix Double}+type Measurement = Vector Double++kalman :: System -> State -> Measurement -> State+kalman (System f h q r) (State x p) z = State x' p' where+    px = f <> x                            -- prediction+    pq = f <> p <> trans f                 -- its covariance+    y  = z - h <> px                       -- residue+    cy = h <> pq <> trans h + r            -- its covariance+    k  = pq <> trans h <> inv cy           -- kalman gain+    x' = px + k <> y                       -- new state+    p' = (ident (dim x) - k <> h) <> pq   -- its covariance++sys = System f h q r++zs = [vector [15-k,-20-k] | k <- [0..]]++xs = s0 : zipWith (kalman sys) xs zs++des = map (sqrt.takeDiag.sP) xs++evolution n (xs,des) =+    vector [1.. fromIntegral n]:(toColumns $ fromRows $ take n (zipWith (-) (map sX xs) des)) +++    (toColumns $ fromRows $ take n (zipWith (+) (map sX xs) des))++main = do+    print $ fromRows $ take 10 (map sX xs)+    mapM_ (print . sP) $ take 10 xs+    mplot (evolution 20 (xs,des))++--(<>) = multiply
+ examples/latexmat.hs view
@@ -0,0 +1,11 @@+import Numeric.LinearAlgebra+import Text.Printf++disp w l fmt m = unlines $ map (++l) $ lines $ format w (printf fmt) m++latex fmt m = "\\begin{bmatrix}\n" ++ disp " & " " \\\\" fmt m ++ "\\end{bmatrix}"++main = do+    let m = (3><4) [1..12::Double]+    putStrLn $ disp " | " "" "%.2f" m+    putStrLn $ latex "%.3f" m
+ examples/lie.hs view
@@ -0,0 +1,66 @@+-- The magic of Lie Algebra++import Numeric.LinearAlgebra+import Text.Printf(printf)++disp = putStrLn . format "  " (printf "%.5f")++rot1 :: Double -> Matrix Double+rot1 a = (3><3)+ [ 1, 0, 0+ , 0, c, s+ , 0,-s, c ]+    where c = cos a+          s = sin a++g1,g2,g3 :: Matrix Double++g1 = (3><3) [0, 0,0+            ,0, 0,1+            ,0,-1,0]++rot2 :: Double -> Matrix Double+rot2 a = (3><3)+ [ c, 0, s+ , 0, 1, 0+ ,-s, 0, c ]+    where c = cos a+          s = sin a++g2 = (3><3) [ 0,0,1+            , 0,0,0+            ,-1,0,0]++rot3 :: Double -> Matrix Double+rot3 a = (3><3)+ [ c, s, 0+ ,-s, c, 0+ , 0, 0, 1 ]+    where c = cos a+          s = sin a++g3 = (3><3) [ 0,1,0+            ,-1,0,0+            , 0,0,0]++deg=pi/180++-- commutator+infix 8 &+a & b = a <> b - b <> a++infixl 6 |+|+a |+| b = a + b + a & b */2  + (a-b) & (a & b) */12++main = do+   let a =  45*deg+       b =  50*deg+       c = -30*deg+       exact = rot3 a <> rot1 b <> rot2 c+       lie = a.*g3 |+| b.*g1 |+| c.*g2+   putStrLn "position in the tangent space:"+   disp lie+   putStrLn "exponential map back to the group (2 terms):"+   disp (expm lie)+   putStrLn "exact position:"+   disp exact
+ examples/minimize.hs view
@@ -0,0 +1,46 @@+-- the multidimensional minimization example in the GSL manual+import Numeric.GSL+import Numeric.LinearAlgebra+import Graphics.Plot+import Text.Printf(printf)++-- the function to be minimized +f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30++-- its gradient+df [x,y] = [20*(x-1), 40*(y-2)]++-- the conjugate gradient method+minimizeCG = minimizeConjugateGradient 1E-2 1E-4 1E-3 30++-- a minimization algorithm which does not require the gradient+minimizeS f xi = minimizeNMSimplex f xi (replicate (length xi) 1) 1E-2 100++-- Numerical estimation of the gradient+gradient f v = [partialDerivative k f v | k <- [0 .. length v -1]]++partialDerivative n f v = fst (derivCentral 0.01 g (v!!n)) where+    g x = f (concat [a,x:b])+    (a,_:b) = splitAt n v++main = do+    -- conjugate gradient with true gradient+    let (s,p) = minimizeCG f df [5,7]+    print s -- solution+    disp p -- evolution of the algorithm+    let [x,y] = drop 2 (toColumns p)+    mplot [x,y]  -- path from the starting point to the solution++    -- conjugate gradient with estimated gradient+    let (s,p) = minimizeCG f (gradient f) [5,7]+    print s+    disp p+    mplot $ drop 2 (toColumns p)++    -- without gradient, using the NM Simplex method+    let (s,p) = minimizeS f [5,7]+    print s+    disp p+    mplot $ drop 3 (toColumns p)++disp = putStrLn . format "  " (printf "%.2f")
+ examples/pca1.hs view
@@ -0,0 +1,47 @@+-- Principal component analysis++import Numeric.LinearAlgebra+import System.Directory(doesFileExist)+import System(system)+import Control.Monad(when)++type Vec = Vector Double+type Mat = Matrix Double++sumColumns m = constant 1 (rows m) <> m++-- Vec with the mean value of the columns of a Mat+mean x = sumColumns x / fromIntegral (rows x)++-- covariance Mat of a list of observations as rows of a Mat+cov x = (trans xc <> xc) / fromIntegral (rows x -1)+    where xc = center x+          center m = m - constant 1 (rows m) `outer` mean m++-- creates the compression and decompression functions from the desired number of components+pca :: Int -> Mat -> (Vec -> Vec , Vec -> Vec)+pca n dataSet = (encode,decode)+  where+    encode x = vp <> (x - m)+    decode x = x <> vp + m+    m = mean dataSet+    c = cov dataSet+    (_,v) = eigSH c+    vp = takeRows n (trans v)++norm = pnorm PNorm2++main = do+    ok <- doesFileExist ("mnist.txt")+    when (not ok)  $ do+        putStrLn "\nTrying to download test datafile..."+        system("wget -nv http://dis.um.es/~alberto/material/sp/mnist.txt.gz")+        system("gunzip mnist.txt.gz")+        return ()+    m <- fromFile "mnist.txt" (5000,785)+    let xs = takeColumns (cols m -1) m -- the last column is the digit type (class label)+    let x = toRows xs !! 4  -- an arbitrary test Vec+    let (pe,pd) = pca 10 xs+    let y = pe x+    print y  -- compressed version+    print $ norm (x - pd y) / norm x --reconstruction quality
+ examples/pca2.hs view
@@ -0,0 +1,67 @@+-- Improved PCA, including illustrative graphics++import Numeric.LinearAlgebra+import Graphics.Plot+import System.Directory(doesFileExist)+import System(system)+import Control.Monad(when)++type Vec = Vector Double+type Mat = Matrix Double++sumColumns m = constant 1 (rows m) <> m++-- Vector with the mean value of the columns of a Mat+mean x = sumColumns x / fromIntegral (rows x)++-- covariance matrix of a list of observations as rows of a matrix+cov x = (trans xc <> xc) / fromIntegral (rows x -1) +    where xc = center x+          center m = m - constant 1 (rows m) `outer` mean m++type Stat = (Vec, [Double], Mat)+-- 1st and 2nd order statistics of a dataset (mean, eigenvalues and eigenvectors of cov)  +stat :: Mat -> Stat+stat x = (m, toList s, trans v) where   +    m = mean x+    (s,v) = eigSH' (cov x)   ++-- creates the compression and decompression functions from the desired reconstruction +-- quality and the statistics of a data set+pca :: Double -> Stat -> (Vec -> Vec , Vec -> Vec)+pca prec (m,s,v) = (encode,decode)    +  where    +    encode x = vp <> (x - m)+    decode x = x <> vp + m+    vp = takeRows n v    +    n = 1 + (length $ fst $ span (< (prec'*sum s)) $ cumSum s)+    cumSum = tail . scanl (+) 0.0     +    prec' = if prec <=0.0 || prec >= 1.0+                then error "the precision in pca must be 0<prec<1"+                else prec++shdigit :: Vec -> IO ()+shdigit v = imshow (reshape 28 (-v))++-- shows the effect of a given reconstruction quality on a test vector+test :: Stat -> Double -> Vec -> IO ()+test st prec x = do+    let (pe,pd) = pca prec st+    let y = pe x+    print $ dim y+    shdigit (pd y)    ++main = do+    ok <- doesFileExist ("mnist.txt")+    when (not ok)  $ do+        putStrLn "\nTrying to download test datafile..."+        system("wget -nv http://dis.um.es/~alberto/material/sp/mnist.txt.gz")+        system("gunzip mnist.txt.gz")+        return ()+    m <- fromFile "mnist.txt" (5000,785)+    let xs = takeColumns (cols m -1) m+    let x = toRows xs !! 4  -- an arbitrary test vector+    shdigit x+    let st = stat xs+    test st 0.90 x+    test st 0.50 x
+ examples/pinv.hs view
@@ -0,0 +1,20 @@+import Numeric.LinearAlgebra+import Graphics.Plot+import Text.Printf(printf)++expand :: Int -> Vector Double -> Matrix Double+expand n x = fromColumns $ constant 1 (dim x): map (x^) [1 .. n]++polynomialModel :: Vector Double -> Vector Double -> Int+                -> (Vector Double -> Vector Double)+polynomialModel x y n = f where+    f z = expand n z <> ws+    ws  = expand n x <\> y++main = do+    [x,y] <- (toColumns . readMatrix) `fmap` readFile "data.txt"+    let pol = polynomialModel x y+    let view = [x, y, pol 1 x, pol 2 x, pol 3 x]+    putStrLn $ "  x      y      p 1    p 2    p 3"+    putStrLn $ format "  " (printf "%.2f") $ fromColumns view+    mplot view
+ examples/plot.hs view
@@ -0,0 +1,20 @@+import Numeric.LinearAlgebra+import Graphics.Plot+import Numeric.GSL(erf_Z, erf)++sombrero n = f x y where +    (x,y) = meshdom range range+    range = linspace n (-2,2)+    f x y = exp (-r2) * cos (2*r2) where +        r2 = x*x+y*y++f x =  sin x + 0.5 * sin (5*x)++gaussianPDF = erf_Z+cumdist x = 0.5 * (1+ erf (x/sqrt 2))++main = do+    let x = linspace 1000 (-4,4)+    mplot [f x]+    mplot [x, liftVector cumdist x,  liftVector gaussianPDF x]+    mesh (sombrero 40)
+ examples/tests.hs view
@@ -0,0 +1,469 @@+{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-}++module Main where++import Data.Packed.Internal((>|<), multiply', multiplyG, MatrixOrder(..),debug,fmat)+import Numeric.GSL hiding (sin,cos,exp,choose)+import Numeric.LinearAlgebra+import Numeric.LinearAlgebra.Linear(Linear)+import Numeric.LinearAlgebra.LAPACK+import Numeric.GSL.Matrix(svdg)+import qualified Numeric.GSL.Matrix as GSL+import Test.QuickCheck hiding (test)+import Test.HUnit hiding ((~:),test)+import System.Random(randomRs,mkStdGen)+import System.Info+import Data.List(foldl1')+import System(getArgs)++type RM = Matrix Double+type CM = Matrix (Complex Double)++-- relative error+dist :: (Normed t, Num t) => t -> t -> Double+dist a b = f nab na nb+    where norm = pnorm Infinity+          na = norm a+          nb = norm b+          nab = norm (a-b)+          f _ a 0 = a+          f _ 0 b = b+          f d a b = d / max a b++infixl 4 |~|+a |~| b = a :~10~: b++data Aprox a = (:~) a Int++(~:) :: (Normed a, Num a) => Aprox a -> a -> Bool+a :~n~: b = dist a b < 10^^(-n)+++maxdim = 10++instance (Arbitrary a, RealFloat a) => Arbitrary (Complex a) where+    arbitrary = do+        r <- arbitrary+        i <- arbitrary+        return (r:+i)+    coarbitrary = undefined++instance (Element a, Arbitrary a) => Arbitrary (Matrix a) where +   arbitrary = do --m <- sized $ \max -> choose (1,1+3*max)+                  m <- choose (1,maxdim)+                  n <- choose (1,maxdim)+                  l <- vector (m*n)+                  ctype <- arbitrary+                  let h = if ctype then (m><n) else (m>|<n)+                  trMode <- arbitrary+                  let tr = if trMode then trans else id+                  return $ tr (h l)+   coarbitrary = undefined++data PairM a = PairM (Matrix a) (Matrix a) deriving Show+instance (Num a, Element a, Arbitrary a) => Arbitrary (PairM a) where+    arbitrary = do+        a <- choose (1,maxdim)+        b <- choose (1,maxdim)+        c <- choose (1,maxdim)+        l1 <- vector (a*b)+        l2 <- vector (b*c)+        return $ PairM ((a><b) (map fromIntegral (l1::[Int]))) ((b><c) (map fromIntegral (l2::[Int])))+        --return $ PairM ((a><b) l1) ((b><c) l2)+    coarbitrary = undefined++data SqM a = SqM (Matrix a) deriving Show+sqm (SqM a) = a+instance (Element a, Arbitrary a) => Arbitrary (SqM a) where+    arbitrary = do+        n <- choose (1,maxdim)+        l <- vector (n*n)+        return $ SqM $ (n><n) l+    coarbitrary = undefined++data Sym a = Sym (Matrix a) deriving Show+sym (Sym a) = a+instance (Linear Vector a, Arbitrary a) => Arbitrary (Sym a) where+    arbitrary = do+        SqM m <- arbitrary+        return $ Sym (m + trans m)+    coarbitrary = undefined++data Her = Her (Matrix (Complex Double)) deriving Show+her (Her a) = a+instance {-(Field a, Arbitrary a, Num a) =>-} Arbitrary Her where+    arbitrary = do+        SqM m <- arbitrary+        return $ Her (m + ctrans m)+    coarbitrary = undefined++data PairSM a = PairSM (Matrix a) (Matrix a) deriving Show+instance (Num a, Field a, Arbitrary a) => Arbitrary (PairSM a) where+    arbitrary = do+        a <- choose (1,maxdim)+        c <- choose (1,maxdim)+        l1 <- vector (a*a)+        l2 <- vector (a*c)+        return $ PairSM ((a><a) (map fromIntegral (l1::[Int]))) ((a><c) (map fromIntegral (l2::[Int])))+        --return $ PairSM ((a><a) l1) ((a><c) l2)+    coarbitrary = undefined++instance (Field a, Arbitrary a) => Arbitrary (Vector a) where +   arbitrary = do --m <- sized $ \max -> choose (1,1+3*max)+                  m <- choose (1,maxdim^2)+                  l <- vector m+                  return $ fromList l+   coarbitrary = undefined++data PairV a = PairV (Vector a) (Vector a)+instance (Field a, Arbitrary a) => Arbitrary (PairV a) where +   arbitrary = do --m <- sized $ \max -> choose (1,1+3*max)+                  m <- choose (1,maxdim^2)+                  l1 <- vector m+                  l2 <- vector m+                  return $ PairV (fromList l1) (fromList l2)+   coarbitrary = undefined++----------------------------------------------------------------------++test str b = TestCase $ assertBool str b++----------------------------------------------------------------------++pseudorandomR seed (n,m) = reshape m $ fromList $ take (n*m) $ randomRs (-100,100) $ mkStdGen seed ++pseudorandomC seed (n,m) = toComplex (pseudorandomR seed (n,m), pseudorandomR (seed+1) (n,m))++bigmat = m + trans m :: RM+    where m = pseudorandomR 18 (1000,1000)+bigmatc = mc + ctrans mc ::CM+    where mc = pseudorandomC 19 (1000,1000)++----------------------------------------------------------------------+++m = (3><3)+ [ 1, 2, 3+ , 4, 5, 7+ , 2, 8, 4 :: Double+ ]++mc = (3><3)+ [ 1, 2, 3+ , 4, 5, 7+ , 2, 8, i+ ]+++mr = (3><4)+ [ 1, 2, 3, 4,+   2, 4, 6, 8,+   1, 1, 1, 2:: Double+ ]++mrc = (3><4)+ [ 1, 2, 3, 4,+   2, 4, 6, 8,+   i, i, i, 2+ ]++a = (3><4)+ [ 1, 0, 0, 0+ , 0, 2, 0, 0+ , 0, 0, 0, 0 :: Double+ ]++b = (3><4)+ [ 1, 0, 0, 0+ , 0, 2, 3, 0+ , 0, 0, 4, 0 :: Double+ ]++ac = (2><3) [1 .. 6::Double]+bc = (3><4) [7 .. 18::Double]++af = (2>|<3) [1,4,2,5,3,6::Double]+bf = (3>|<4) [7,11,15,8,12,16,9,13,17,10,14,18::Double]++-------------------------------------------------------++detTest = det m == 26 && det mc == 38 :+ (-3)++invTest m = degenerate m || m <> inv m |~| ident (rows m)++pinvTest m =  m <> p <> m |~| m+           && p <> m <> p |~| p+           && hermitian (m<>p)+           && hermitian (p<>m)+    where p = pinv m++square m = rows m == cols m++unitary m = square m && m <> ctrans m |~| ident (rows m)++hermitian m = m |~| ctrans m++upperTriang m = rows m == 1 || down == z+    where down = fromList $ concat $ zipWith drop [1..] (toLists (ctrans m))+          z = constant 0 (dim down)++upperHessenberg m = rows m < 3 || down == z+    where down = fromList $ concat $ zipWith drop [2..] (toLists (ctrans m))+          z = constant 0 (dim down)++svdTest svd m = u <> real d <> trans v |~| m+          && unitary u && unitary v+    where (u,d,v) = full svd m++svdTest' svd m = m |~| 0 || u <> real (diag s) <> trans v |~| m+    where (u,s,v) = economy svd m++eigTest m = complex m <> v |~| v <> diag s+    where (s, v) = eig m++eigTestSH m = m <> v |~| v <> real (diag s)+              && unitary v+              && m |~| v <> real (diag s) <> ctrans v+    where (s, v) = eigSH m++zeros (r,c) = reshape c (constant 0 (r*c))++ones (r,c) = zeros (r,c) + 1++degenerate m = rank m < min (rows m) (cols m) ++prec = 1E-15++singular m = s1 < prec || s2/s1 < prec+    where (_,ss,_) = svd m+          s = toList ss+          s1 = maximum s+          s2 = minimum s++nullspaceTest m = null nl || m <> n |~| zeros (r,c) -- 0+    where nl = nullspacePrec 1 m+          n = fromColumns nl+          r = rows m+          c = cols m - rank m++--------------------------------------------------------------------++polyEval cs x = foldr (\c ac->ac*x+c) 0 cs++polySolveTest' p = length p <2 || last p == 0|| 1E-8 > maximum (map magnitude $ map (polyEval (map (:+0) p)) (polySolve p))+++polySolveTest = test "polySolve" (polySolveTest' [1,2,3,4])++---------------------------------------------------------------------++quad f a b = fst $ integrateQAGS 1E-9 100 f a b++-- A multiple integral can be easily defined using partial application+quad2 f a b g1 g2 = quad h a b+    where h x = quad (f x) (g1 x) (g2 x)++volSphere r = 8 * quad2 (\x y -> sqrt (r*r-x*x-y*y)) +                        0 r (const 0) (\x->sqrt (r*r-x*x))++epsTol = 1E-8::Double++integrateTest = test "integrate" (abs (volSphere 2.5 - 4/3*pi*2.5^3) < epsTol)++---------------------------------------------------------------------++besselTest = test "bessel_J0_e" ( abs (r-expected) < e )+    where (r,e) = bessel_J0_e 5.0+          expected = -0.17759677131433830434739701++exponentialTest = test "exp_e10_e" ( abs (v*10^e - expected) < 4E-2 )+    where (v,e,err) = exp_e10_e 30.0+          expected = exp 30.0++gammaTest = test "gamma" (gamma 5 == 24.0)++---------------------------------------------------------------------++cholRTest = chol ((2><2) [1,2,2,9::Double]) == (2><2) [1,2,0,2.23606797749979]+cholCTest = chol ((2><2) [1,2,2,9::Complex Double]) == (2><2) [1,2,0,2.23606797749979]++---------------------------------------------------------------------++qrTest qr m = q <> r |~| m && unitary q && upperTriang r+    where (q,r) = qr m++---------------------------------------------------------------------++hessTest m = m |~| p <> h <> ctrans p && unitary p && upperHessenberg h+    where (p,h) = hess m++---------------------------------------------------------------------++schurTest1 m = m |~| u <> s <> ctrans u && unitary u && upperTriang s+    where (u,s) = schur m++schurTest2 m = m |~| u <> s <> ctrans u && unitary u && upperHessenberg s -- fixme+    where (u,s) = schur m++---------------------------------------------------------------------++nd1 = (3><3) [ 1/2, 1/4, 1/4+             , 0/1, 1/2, 1/4+             , 1/2, 1/4, 1/2 :: Double]++nd2 = (2><2) [1, 0, 1, 1:: Complex Double]++expmTest1 = expm nd1 :~14~: (3><3)+ [ 1.762110887278176+ , 0.478085470590435+ , 0.478085470590435+ , 0.104719410945666+ , 1.709751181805343+ , 0.425725765117601+ , 0.851451530235203+ , 0.530445176063267+ , 1.814470592751009 ]++expmTest2 = expm nd2 :~15~: (2><2)+ [ 2.718281828459045+ , 0.000000000000000+ , 2.718281828459045+ , 2.718281828459045 ]++expmTestDiag m = expm (logm m) |~| complex m+    where logm m = matFunc Prelude.log m++++---------------------------------------------------------------------++asFortran m = (rows m >|< cols m) $ toList (flatten $ trans  m)+asC m = (rows m >< cols m) $ toList (flatten m)++mulC a b = multiply' RowMajor a b+mulF a b = multiply' ColumnMajor a b++---------------------------------------------------------------------++rot :: Double -> Matrix Double+rot a = (3><3) [ c,0,s+               , 0,1,0+               ,-s,0,c ]+    where c = cos a+          s = sin a++fun n = foldl1' (<>) (map rot angles)+    where angles = toList $ linspace n (0,1)++rotTest = fun (10^5) :~12~: rot 5E4++---------------------------------------------------------------------++tests = do+    setErrorHandlerOff+    putStrLn "--------- internal -----"+    quickCheck ((\m -> m == trans m).sym :: Sym Double -> Bool)+    quickCheck ((\m -> m == trans m).sym :: Sym (Complex Double) -> Bool)+    quickCheck $ \l -> null l || (toList . fromList) l == (l :: [Double])+    quickCheck $ \l -> null l || (toList . fromList) l == (l :: [Complex Double])+    quickCheck $ \m -> m == asC (m :: RM)+    quickCheck $ \m -> m == asC (m :: CM)+    quickCheck $ \m -> m == asFortran (m :: RM)+    quickCheck $ \m -> m == asFortran (m :: CM)+    quickCheck $ \m -> m == (asC . asFortran) (m :: RM)+    quickCheck $ \m -> m == (asC . asFortran) (m :: CM)+    runTestTT $ TestList+     [ test "1E5 rots" rotTest+     ]+    putStrLn "--------- multiply ----"+    quickCheck $ \(PairM m1 m2) -> mulC m1 m2 == mulF m1 (m2 :: RM)+    quickCheck $ \(PairM m1 m2) -> mulC m1 m2 == mulF m1 (m2 :: CM)+    quickCheck $ \(PairM m1 m2) -> mulC m1 m2 == trans (mulF (trans m2) (trans m1 :: RM))+    quickCheck $ \(PairM m1 m2) -> mulC m1 m2 == trans (mulF (trans m2) (trans m1 :: CM))+    quickCheck $ \(PairM m1 m2) -> mulC m1 m2 == multiplyG m1 (m2 :: RM)+    quickCheck $ \(PairM m1 m2) -> mulC m1 m2 == multiplyG m1 (m2 :: CM)+    putStrLn "--------- svd ---------"+    quickCheck (svdTest svdR)+    quickCheck (svdTest svdRdd)+    quickCheck (svdTest svdC)+    quickCheck (svdTest' svdR)+    quickCheck (svdTest' svdRdd)+    quickCheck (svdTest' svdC)+    quickCheck (svdTest' svdg)+    putStrLn "--------- eig ---------"+    quickCheck (eigTest  . sqm :: SqM Double -> Bool)+    quickCheck (eigTest  . sqm :: SqM (Complex Double) -> Bool)+    quickCheck (eigTestSH . sym :: Sym Double -> Bool)+    quickCheck (eigTestSH . her :: Her -> Bool)+    putStrLn "--------- inv ------"+    quickCheck (invTest . sqm   :: SqM Double -> Bool)+    quickCheck (invTest . sqm   :: SqM (Complex Double) -> Bool)+    putStrLn "--------- pinv ------"+    quickCheck (pinvTest ::RM->Bool)+    if os == "mingw32"+        then putStrLn "complex pinvTest skipped in this OS"+        else quickCheck (pinvTest ::CM->Bool)+    putStrLn "--------- chol ------"+    runTestTT $ TestList+     [ test "cholR" cholRTest+     , test "cholC" cholRTest+     ]+    putStrLn "--------- qr ---------"+    quickCheck (qrTest GSL.qr)+    quickCheck (qrTest (GSL.unpackQR . GSL.qrPacked))+    quickCheck (qrTest (    unpackQR . GSL.qrPacked))+    quickCheck (qrTest qr ::RM->Bool)+    quickCheck (qrTest qr ::CM->Bool)+    putStrLn "--------- hess --------"+    quickCheck (hessTest . sqm ::SqM Double->Bool)+    quickCheck (hessTest . sqm ::SqM (Complex Double) -> Bool)+    putStrLn "--------- schur --------"+    quickCheck (schurTest2 . sqm ::SqM Double->Bool)+    if os == "mingw32"+        then putStrLn "complex schur skipped in this OS"+        else quickCheck (schurTest1 . sqm ::SqM (Complex Double) -> Bool)+    putStrLn "--------- expm --------"+    runTestTT $ TestList+     [ test "expmd" (expmTestDiag $ (2><2) [1,2,3,5 :: Double])+     , test "expm1" (expmTest1)+     , test "expm2" (expmTest2)+     ]+    putStrLn "--------- nullspace ------"+    quickCheck (nullspaceTest :: RM -> Bool)+    quickCheck (nullspaceTest :: CM -> Bool)+    putStrLn "--------- vector operations ------"+    quickCheck $ (\u -> sin u ^ 2 + cos u ^ 2 |~| (1::RM))+    quickCheck $ (\u -> sin u ** 2 + cos u ** 2 |~| (1::RM))+    quickCheck $ (\u -> cos u * tan u |~| sin (u::RM))+    quickCheck $ (\u -> (cos u * tan u) :~6~: sin (u::CM))+    runTestTT $ TestList+     [ test "arith1" $ ((ones (100,100) * 5 + 2)/0.5 - 7)**2 |~| (49 :: RM)+     , test "arith2" $ (((1+i) .* ones (100,100) * 5 + 2)/0.5 - 7)**2 |~| ( (140*i-51).*1 :: CM)+     , test "arith3" $ exp (i.*ones(10,10)*pi) + 1 |~| 0+     , test "<\\>"   $ (3><2) [2,0,0,3,1,1::Double] <\> 3|>[4,9,5] |~| 2|>[2,3]+     ]+    putStrLn "--------- GSL ------"+    quickCheck $ \v -> ifft (fft v) |~| v+    runTestTT $ TestList+     [ gammaTest+     , besselTest+     , exponentialTest+     , integrateTest+     , polySolveTest+     , test "det" detTest+     ]++bigtests = do+    putStrLn "--------- big matrices -----"+    runTestTT $ TestList+     [ test "eigS" $ eigTestSH bigmat+     , test "eigH" $ eigTestSH bigmatc+     , test "eigR" $ eigTest   bigmat+     , test "eigC" $ eigTest   bigmatc+     ]++main = do+    args <- getArgs+    if "--big" `elem` args+        then bigtests+        else tests
+ hmatrix.cabal view
@@ -0,0 +1,95 @@+Name:               hmatrix+Version:            0.1.0.0+License:            GPL+License-file:       LICENSE+Author:             Alberto Ruiz+Maintainer:         Alberto Ruiz <aruiz@um.es>+Stability:          provisional+Homepage:           http://alberrto.googlepages.com/gslhaskell+Synopsis:           Linear algebra and numerical computations+Description:        A purely functional interface to basic linear algebra computations+                    and other numerical routines, internally implemented using+                    GSL, BLAS and LAPACK.+                    .+                    More information: <http://alberrto.googlepages.com/gslhaskell>+Category:           Numerical, Math+tested-with:        GHC ==6.6.1, GHC ==6.8.1++cabal-version:      >=1.2++flag splitBase+    description:    Choose the new smaller, split-up base package.++library+    if flag(splitBase)+      build-depends:    base >= 3, array+    else+      build-depends:    base < 3++    ghc-options:        -O++    if os(windows)+      ghc-options:      -fasm+    else+      ghc-options:      -fvia-C++    Build-Depends:      haskell98+    Extensions:         ForeignFunctionInterface++    hs-source-dirs:     lib+    Exposed-modules:    Data.Packed.Internal,+                        Data.Packed.Internal.Common,+                        Data.Packed.Internal.Vector+                        Data.Packed.Internal.Matrix,+                        Data.Packed,+                        Data.Packed.Vector,+                        Data.Packed.Matrix,+                        Numeric.GSL.Vector,+                        Numeric.GSL.Matrix,+                        Numeric.GSL.Differentiation,+                        Numeric.GSL.Integration,+                        Numeric.GSL.Fourier,+                        Numeric.GSL.Polynomials,+                        Numeric.GSL.Minimization,+                        Numeric.GSL.Special,+                        Numeric.GSL.Special.Internal,+                        Numeric.GSL.Special.Gamma,+                        Numeric.GSL.Special.Erf,+                        Numeric.GSL.Special.Airy,+                        Numeric.GSL.Special.Exp,+                        Numeric.GSL.Special.Bessel,+                        Numeric.GSL.Special.Clausen,+                        Numeric.GSL.Special.Coulomb,+                        Numeric.GSL.Special.Coupling,+                        Numeric.GSL.Special.Dawson,+                        Numeric.GSL.Special.Debye,+                        Numeric.GSL.Special.Dilog,+                        Numeric.GSL.Special.Elementary,+                        Numeric.GSL.Special.Ellint,+                        Numeric.GSL.Special.Expint,+                        Numeric.GSL.Special.Fermi_dirac,+                        Numeric.GSL.Special.Gegenbauer,+                        Numeric.GSL.Special.Hyperg,+                        Numeric.GSL.Special.Laguerre,+                        Numeric.GSL.Special.Lambert,+                        Numeric.GSL.Special.Pow_int,+                        Numeric.GSL.Special.Psi,+                        Numeric.GSL.Special.Synchrotron,+                        Numeric.GSL.Special.Trig,+                        Numeric.GSL.Special.Zeta,+                        Numeric.GSL.Special.Log,+                        Numeric.GSL.Special.Legendre,+                        Numeric.GSL,+                        Numeric.LinearAlgebra,+                        Numeric.LinearAlgebra.LAPACK,+                        Numeric.LinearAlgebra.Linear,+                        Numeric.LinearAlgebra.Instances,+                        Numeric.LinearAlgebra.Interface,+                        Numeric.LinearAlgebra.Algorithms,+                        Graphics.Plot+    C-sources:          lib/Data/Packed/Internal/auxi.c,+                        lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c,+                        lib/Numeric/GSL/gsl-aux.c+    extra-libraries:    gsl blas lapack+    cc-options:         -O4+    ghc-prof-options:   -auto-all
+ lib/Data/Packed.hs view
@@ -0,0 +1,70 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+{- |+Module      :  Data.Packed+Copyright   :  (c) Alberto Ruiz 2006-7+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++The Vector and Matrix types and some utilities.++-}+-----------------------------------------------------------------------------++module Data.Packed (+    module Data.Packed.Vector,+    module Data.Packed.Matrix,+    module Data.Complex,+    Container(..)+) where++import Data.Packed.Vector+import Data.Packed.Matrix+import Data.Complex+import Data.Packed.Internal(fromComplex,toComplex,comp,conj)++-- | conversion utilities+class (Element e) => Container c e where+    toComplex   :: RealFloat e => (c e, c e) -> c (Complex e)+    fromComplex :: RealFloat e => c (Complex e) -> (c e, c e)+    comp        :: RealFloat e => c e -> c (Complex e)+    conj        :: RealFloat e => c (Complex e) -> c (Complex e)+    real        :: c Double -> c e+    complex     :: c e -> c (Complex Double)++instance Container Vector Double where+    toComplex = Data.Packed.Internal.toComplex+    fromComplex = Data.Packed.Internal.fromComplex+    comp = Data.Packed.Internal.comp+    conj = Data.Packed.Internal.conj+    real = id+    complex = Data.Packed.comp++instance Container Vector (Complex Double) where+    toComplex = undefined -- can't match+    fromComplex = undefined+    comp = undefined+    conj = undefined+    real = Data.Packed.comp+    complex = id++instance Container Matrix Double where+    toComplex = uncurry $ liftMatrix2 $ curry Data.Packed.toComplex+    fromComplex z = (reshape c r, reshape c i)+        where (r,i) = Data.Packed.fromComplex (flatten z)+              c = cols z+    comp = liftMatrix Data.Packed.Internal.comp+    conj = liftMatrix Data.Packed.Internal.conj+    real = id+    complex = Data.Packed.comp++instance Container Matrix (Complex Double) where+    toComplex = undefined+    fromComplex = undefined+    comp = undefined+    conj = undefined+    real = Data.Packed.comp+    complex = id
+ lib/Data/Packed/Internal.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Packed.Internal+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable+--+-- Reexports all internal modules+--+-----------------------------------------------------------------------------+-- #hide++module Data.Packed.Internal (+    module Data.Packed.Internal.Common,+    module Data.Packed.Internal.Vector,+    module Data.Packed.Internal.Matrix,+) where++import Data.Packed.Internal.Common+import Data.Packed.Internal.Vector+import Data.Packed.Internal.Matrix
+ lib/Data/Packed/Internal/Common.hs view
@@ -0,0 +1,144 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Packed.Internal.Common+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable (uses FFI)+--+-- Development utilities.+--+-----------------------------------------------------------------------------+-- #hide++module Data.Packed.Internal.Common where++import Foreign+import Complex+import Control.Monad(when)+import Debug.Trace+import Foreign.C.String(peekCString)+import Foreign.C.Types++----------------------------------------------------------------------+instance (Storable a, RealFloat a) => Storable (Complex a) where    --+    alignment x = alignment (realPart x)                            --+    sizeOf x    = 2 * sizeOf (realPart x)                           --+    peek p = do                                                     --+        [re,im] <- peekArray 2 (castPtr p)                          --+        return (re :+ im)                                           --+    poke p (a :+ b) = pokeArray (castPtr p) [a,b]                   --+----------------------------------------------------------------------++-- | @debug x = trace (show x) x@+debug :: (Show a) => a -> a+debug x = trace (show x) x++-- | useful for expressions like @sortBy (compare \`on\` length)@+on :: (a -> a -> b) -> (t -> a) -> t -> t -> b+on f g = \x y -> f (g x) (g y)++-- | @partit 3 [1..9] == [[1,2,3],[4,5,6],[7,8,9]]@+partit :: Int -> [a] -> [[a]]+partit _ [] = []+partit n l  = take n l : partit n (drop n l)++-- | obtains the common value of a property of a list+common :: (Eq a) => (b->a) -> [b] -> Maybe a+common f = commonval . map f where+    commonval :: (Eq a) => [a] -> Maybe a+    commonval [] = Nothing+    commonval [a] = Just a+    commonval (a:b:xs) = if a==b then commonval (b:xs) else Nothing++-- | postfix function application (@flip ($)@)+(//) :: x -> (x -> y) -> y+infixl 0 //+(//) = flip ($)++-- hmm..+ww2 w1 o1 w2 o2 f = w1 o1 $ \a1 -> w2 o2 $ \a2 -> f a1 a2+ww3 w1 o1 w2 o2 w3 o3 f = w1 o1 $ \a1 -> ww2 w2 o2 w3 o3 (f a1)+ww4 w1 o1 w2 o2 w3 o3 w4 o4 f = w1 o1 $ \a1 -> ww3 w2 o2 w3 o3 w4 o4 (f a1)++app1 f w1 o1 s = w1 o1 $ \a1 -> f // a1 // check s+app2 f w1 o1 w2 o2 s = ww2 w1 o1 w2 o2 $ \a1 a2 -> f // a1 // a2 // check s+app3 f w1 o1 w2 o2 w3 o3 s = ww3 w1 o1 w2 o2 w3 o3 $+     \a1 a2 a3 -> f // a1 // a2 // a3 // check s+app4 f w1 o1 w2 o2 w3 o3 w4 o4 s = ww4 w1 o1 w2 o2 w3 o3 w4 o4 $ +     \a1 a2 a3 a4 -> f // a1 // a2 // a3 // a4 // check s++-- GSL error codes are <= 1024+-- | error codes for the auxiliary functions required by the wrappers+errorCode :: Int -> String+errorCode 2000 = "bad size"+errorCode 2001 = "bad function code"+errorCode 2002 = "memory problem"+errorCode 2003 = "bad file"+errorCode 2004 = "singular"+errorCode 2005 = "didn't converge"+errorCode 2006 = "the input matrix is not positive definite"+errorCode 2007 = "not yet supported in this OS"+errorCode n    = "code "++show n++-- | check the error code+check :: String -> IO Int -> IO ()+check msg f = do+    err <- f+    when (err/=0) $ if err > 1024+                      then (error (msg++": "++errorCode err)) -- our errors+                      else do                                 -- GSL errors+                        ps <- gsl_strerror err+                        s <- peekCString ps+                        error (msg++": "++s)+    return ()++-- | description of GSL error codes+foreign import ccall "auxi.h gsl_strerror" gsl_strerror :: Int -> IO (Ptr CChar)+++{- | conversion of Haskell functions into function pointers that can be used in the C side+-}+foreign import ccall "wrapper" mkfun:: (Double -> Ptr() -> Double) -> IO( FunPtr (Double -> Ptr() -> Double)) ++---------------------------------------------------+-- ugly, but my haddock version doesn't understand+-- yet infix type constructors+---------------------------------------------------+---------- signatures of the C functions -------+------------------------------------------------+type PD = Ptr Double                          --+type PC = Ptr (Complex Double)                --+type TV = Int -> PD -> IO Int                 --+type TVV = Int -> PD -> TV                    --+type TVVV = Int -> PD -> TVV                  --+type TM = Int -> Int -> PD -> IO Int          --+type TMM =  Int -> Int -> PD -> TM            --+type TMMM =  Int -> Int -> PD -> TMM          --+type TVM = Int -> PD -> TM                    --+type TVVM = Int -> PD -> TVM                  --+type TMV = Int -> Int -> PD -> TV             --+type TMVM = Int -> Int -> PD -> TVM           --+type TMMVM = Int -> Int -> PD -> TMVM         --+type TCM = Int -> Int -> PC -> IO Int         --+type TCVCM = Int -> PC -> TCM                 --+type TCMCVCM = Int -> Int -> PC -> TCVCM      --+type TMCMCVCM = Int -> Int -> PD -> TCMCVCM   --+type TCMCMCVCM = Int -> Int -> PC -> TCMCVCM  --+type TCMCM = Int -> Int -> PC -> TCM          --+type TVCM = Int -> PD -> TCM                  --+type TCMVCM = Int -> Int -> PC -> TVCM        --+type TCMCMVCM = Int -> Int -> PC -> TCMVCM    --+type TCMCMCM = Int -> Int -> PC -> TCMCM      --+type TCV = Int -> PC -> IO Int                --+type TCVCV = Int -> PC -> TCV                 --+type TCVCVCV = Int -> PC -> TCVCV             --+type TCMCV = Int -> Int -> PC -> TCV          --+type TVCV = Int -> PD -> TCV                  --+type TCVM = Int -> PC -> TM                   --+type TMCVM = Int -> Int -> PD -> TCVM         --+type TMMCVM = Int -> Int -> PD -> TMCVM       --+------------------------------------------------
+ lib/Data/Packed/Internal/Matrix.hs view
@@ -0,0 +1,433 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Packed.Internal.Matrix+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable (uses FFI)+--+-- Internal matrix representation+--+-----------------------------------------------------------------------------+-- #hide++module Data.Packed.Internal.Matrix where++import Data.Packed.Internal.Common+import Data.Packed.Internal.Vector++import Foreign hiding (xor)+import Complex+import Control.Monad(when)+import Foreign.C.String+import Foreign.C.Types+import Data.List(transpose)++-----------------------------------------------------------------++{- Design considerations for the Matrix Type+   -----------------------------------------++- we must easily handle both row major and column major order,+  for bindings to LAPACK and GSL/C++- we'd like to simplify redundant matrix transposes:+   - Some of them arise from the order requirements of some functions+   - some functions (matrix product) admit transposed arguments++- maybe we don't really need this kind of simplification:+   - more complex code+   - some computational overhead+   - only appreciable gain in code with a lot of redundant transpositions+     and cheap matrix computations++- we could carry both the matrix and its (lazily computed) transpose.+  This may save some transpositions, but it is necessary to keep track of the+  data which is actually computed to be used by functions like the matrix product+  which admit both orders.++- but if we need the transposed data and it is not in the structure, we must make+  sure that we touch the same foreignptr that is used in the computation.++- a reasonable solution is using two constructors for a matrix. Transposition just+  "flips" the constructor. Actual data transposition is not done if followed by a+  matrix product or another transpose.++-}++data MatrixOrder = RowMajor | ColumnMajor deriving (Show,Eq)++-- | Matrix representation suitable for GSL and LAPACK computations.+data Matrix t = MC { rows :: Int, cols :: Int, cdat :: Vector t }+              | MF { rows :: Int, cols :: Int, fdat :: Vector t }++-- MC: preferred by C, fdat may require a transposition+-- MF: preferred by LAPACK, cdat may require a transposition++-- | Matrix transpose.+trans :: Matrix t -> Matrix t+trans MC {rows = r, cols = c, cdat = d } = MF {rows = c, cols = r, fdat = d }+trans MF {rows = r, cols = c, fdat = d } = MC {rows = c, cols = r, cdat = d }++cmat m@MC{} = m+cmat MF {rows = r, cols = c, fdat = d } = MC {rows = r, cols = c, cdat = transdata r d c}++fmat m@MF{} = m+fmat MC {rows = r, cols = c, cdat = d } = MF {rows = r, cols = c, fdat = transdata c d r}++mat = withMatrix++withMatrix MC {rows = r, cols = c, cdat = d } f =+    withForeignPtr (fptr d) $ \p -> do+        let m g = do+            g r c p+        f m++withMatrix MF {rows = r, cols = c, fdat = d } f =+    withForeignPtr (fptr d) $ \p -> do+        let m g = do+            g r c p+        f m++{- | Creates a vector by concatenation of rows++@\> flatten ('ident' 3)+9 |> [1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0]@+-}+flatten :: Element t => Matrix t -> Vector t+flatten = cdat . cmat+++type Mt t s = Int -> Int -> Ptr t -> s+-- not yet admitted by my haddock version+-- infixr 6 ::>+-- type t ::> s = Mt t s++-- | the inverse of 'Data.Packed.Matrix.fromLists'+toLists :: (Element t) => Matrix t -> [[t]]+toLists m = partit (cols m) . toList . flatten $ m++-- | creates a Matrix from a list of vectors+fromRows :: Element t => [Vector t] -> Matrix t+fromRows vs = case common dim vs of+    Nothing -> error "fromRows applied to [] or to vectors with different sizes"+    Just c  -> reshape c (join vs)++-- | extracts the rows of a matrix as a list of vectors+toRows :: Element t => Matrix t -> [Vector t]+toRows m = toRows' 0 where+    v = flatten $ m+    r = rows m+    c = cols m+    toRows' k | k == r*c  = []+              | otherwise = subVector k c v : toRows' (k+c)++-- | Creates a matrix from a list of vectors, as columns+fromColumns :: Element t => [Vector t] -> Matrix t+fromColumns m = trans . fromRows $ m++-- | Creates a list of vectors from the columns of a matrix+toColumns :: Element t => Matrix t -> [Vector t]+toColumns m = toRows . trans $ m+++-- | Reads a matrix position.+(@@>) :: Storable t => Matrix t -> (Int,Int) -> t+infixl 9 @@>+--m@M {rows = r, cols = c} @@> (i,j)+--    | i<0 || i>=r || j<0 || j>=c = error "matrix indexing out of range"+--    | otherwise   = cdat m `at` (i*c+j)++MC {rows = r, cols = c, cdat = v} @@> (i,j)+    | i<0 || i>=r || j<0 || j>=c = error "matrix indexing out of range"+    | otherwise                  = v `at` (i*c+j)++MF {rows = r, cols = c, fdat = v} @@> (i,j)+    | i<0 || i>=r || j<0 || j>=c = error "matrix indexing out of range"+    | otherwise                  = v `at` (j*r+i)++------------------------------------------------------------------++matrixFromVector RowMajor c v = MC { rows = r, cols = c, cdat = v }+    where (d,m) = dim v `divMod` c+          r | m==0 = d+            | otherwise = error "matrixFromVector"++matrixFromVector ColumnMajor c v = MF { rows = r, cols = c, fdat = v }+    where (d,m) = dim v `divMod` c+          r | m==0 = d+            | otherwise = error "matrixFromVector"++createMatrix order r c = do+    p <- createVector (r*c)+    return (matrixFromVector order c p)++{- | 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 = trans . reshape r@+where r is the desired number of rows.)++@\> reshape 4 ('fromList' [1..12])+(3><4)+ [ 1.0,  2.0,  3.0,  4.0+ , 5.0,  6.0,  7.0,  8.0+ , 9.0, 10.0, 11.0, 12.0 ]@++-}+reshape :: Element t => Int -> Vector t -> Matrix t+reshape c v = matrixFromVector RowMajor c v++singleton x = reshape 1 (fromList [x])++-- | application of a vector function on the flattened matrix elements+liftMatrix :: (Element a, Element b) => (Vector a -> Vector b) -> Matrix a -> Matrix b+liftMatrix f MC { cols = c, cdat = d } = matrixFromVector RowMajor    c (f d)+liftMatrix f MF { cols = c, fdat = d } = matrixFromVector ColumnMajor c (f d)++-- | application of a vector function on the flattened matrices elements+liftMatrix2 :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t+liftMatrix2 f m1 m2+    | not (compat m1 m2) = error "nonconformant matrices in liftMatrix2"+    | otherwise = case m1 of+        MC {} -> matrixFromVector RowMajor    (cols m1) (f (cdat m1) (flatten m2))+        MF {} -> matrixFromVector ColumnMajor (cols m1) (f (fdat m1) ((fdat.fmat) m2))+++compat :: Matrix a -> Matrix b -> Bool+compat m1 m2 = rows m1 == rows m2 && cols m1 == cols m2++----------------------------------------------------------------++-- | Optimized matrix computations are provided for elements in the Element class.+class (Storable a, Floating a) => Element a where+    constantD :: a -> Int -> Vector a+    transdata :: Int -> Vector a -> Int -> Vector a+    multiplyD :: Matrix a -> Matrix a -> Matrix a+    subMatrixD :: (Int,Int) -- ^ (r0,c0) starting position +               -> (Int,Int) -- ^ (rt,ct) dimensions of submatrix+               -> Matrix a -> Matrix a+    diagD :: Vector a -> Matrix a++instance Element Double where+    constantD  = constantR+    transdata = transdataR+    multiplyD  = multiplyR+    subMatrixD = subMatrixR+    diagD      = diagR++instance Element (Complex Double) where+    constantD  = constantC+    transdata  = transdataC+    multiplyD  = multiplyC+    subMatrixD = subMatrixC+    diagD      = diagC++------------------------------------------------------------------++(>|<) :: (Element a) => Int -> Int -> [a] -> Matrix a+r >|< c = f where+    f l | dim v == r*c = matrixFromVector ColumnMajor c v+        | otherwise    = error $ "inconsistent list size = "+                                 ++show (dim v) ++" in ("++show r++"><"++show c++")"+        where v = fromList l++-------------------------------------------------------------------++transdataR :: Int -> Vector Double -> Int -> Vector Double+transdataR = transdataAux ctransR++transdataC :: Int -> Vector (Complex Double) -> Int -> Vector (Complex Double)+transdataC = transdataAux ctransC++transdataAux fun c1 d c2 =+    if noneed+        then d+        else unsafePerformIO $ do+            v <- createVector (dim d)+            withForeignPtr (fptr d) $ \pd ->+                withForeignPtr (fptr v) $ \pv ->+                    fun r1 c1 pd r2 c2 pv // check "transdataAux"+            -- putStrLn $ "---> transdataAux" ++ show (toList d) ++ show (toList v)+            return v+  where r1 = dim d `div` c1+        r2 = dim d `div` c2+        noneed = r1 == 1 || c1 == 1++foreign import ccall safe "auxi.h transR"+    ctransR :: TMM -- Double ::> Double ::> IO Int+foreign import ccall safe "auxi.h transC"+    ctransC :: TCMCM -- Complex Double ::> Complex Double ::> IO Int++------------------------------------------------------------------++gmatC MF { rows = r, cols = c } p f = f 1 c r p+gmatC MC { rows = r, cols = c } p f = f 0 r c p++dtt MC { cdat = d } = d+dtt MF { fdat = d } = d++multiplyAux fun a b = unsafePerformIO $ do+    when (cols a /= rows b) $ error $ "inconsistent dimensions in contraction "+++                                      show (rows a,cols a) ++ " x " ++ show (rows b, cols b)+    r <- createMatrix RowMajor (rows a) (cols b)+    withForeignPtr (fptr (dtt a)) $ \pa -> withForeignPtr (fptr (dtt b)) $ \pb ->+        withMatrix r $ \r' ->+            fun // gmatC a pa // gmatC b pb // r' // check "multiplyAux"+    return r++multiplyR = multiplyAux cmultiplyR+foreign import ccall safe "auxi.h multiplyR"+    cmultiplyR :: Int -> Int -> Int -> Ptr Double+               -> Int -> Int -> Int -> Ptr Double+               -> Int -> Int -> Ptr Double+               -> IO Int++multiplyC = multiplyAux cmultiplyC+foreign import ccall safe "auxi.h multiplyC"+    cmultiplyC :: Int -> Int -> Int -> Ptr (Complex Double)+               -> Int -> Int -> Int -> Ptr (Complex Double)+               -> Int -> Int -> Ptr (Complex Double)+               -> IO Int++multiply' :: (Element a) => MatrixOrder -> Matrix a -> Matrix a -> Matrix a+multiply' RowMajor a b    = multiplyD a b+multiply' ColumnMajor a b = trans $ multiplyD (trans b) (trans a)+++-- | matrix product+multiply :: (Element a) => Matrix a -> Matrix a -> Matrix a+multiply = multiplyD++----------------------------------------------------------------------++-- | extraction of a submatrix from a real matrix+subMatrixR :: (Int,Int) -> (Int,Int) -> Matrix Double -> Matrix Double+subMatrixR (r0,c0) (rt,ct) x' = unsafePerformIO $ do+    r <- createMatrix RowMajor rt ct+    let x = cmat x'+    app2 (c_submatrixR r0 (r0+rt-1) c0 (c0+ct-1)) mat x mat r "subMatrixR"+    return r+foreign import ccall "auxi.h submatrixR" c_submatrixR :: Int -> Int -> Int -> Int -> TMM++-- | extraction of a submatrix from a complex matrix+subMatrixC :: (Int,Int) -> (Int,Int) -> Matrix (Complex Double) -> Matrix (Complex Double)+subMatrixC (r0,c0) (rt,ct) x =+    reshape ct . asComplex . flatten .+    subMatrixR (r0,2*c0) (rt,2*ct) .+    reshape (2*cols x) . asReal . flatten $ x++-- | Extracts a submatrix from a matrix.+subMatrix :: Element a+          => (Int,Int) -- ^ (r0,c0) starting position +          -> (Int,Int) -- ^ (rt,ct) dimensions of submatrix+          -> Matrix a -- ^ input matrix+          -> Matrix a -- ^ result+subMatrix = subMatrixD+++---------------------------------------------------------------------++diagAux fun msg (v@V {dim = n}) = unsafePerformIO $ do+    m <- createMatrix RowMajor n n+    app2 fun vec v mat m msg+    return m++-- | diagonal matrix from a real vector+diagR :: Vector Double -> Matrix Double+diagR = diagAux c_diagR "diagR"+foreign import ccall "auxi.h diagR" c_diagR :: TVM++-- | diagonal matrix from a real vector+diagC :: Vector (Complex Double) -> Matrix (Complex Double)+diagC = diagAux c_diagC "diagC"+foreign import ccall "auxi.h diagC" c_diagC :: TCVCM++-- | creates a square matrix with the given diagonal+diag :: Element a => Vector a -> Matrix a+diag = diagD++------------------------------------------------------------------------++constantAux fun x n = unsafePerformIO $ do+    v <- createVector n+    px <- newArray [x]+    app1 (fun px) vec v "constantAux"+    free px+    return v++constantR :: Double -> Int -> Vector Double+constantR = constantAux cconstantR+foreign import ccall "auxi.h constantR"+    cconstantR :: Ptr Double -> TV -- Double :> IO Int++constantC :: Complex Double -> Int -> Vector (Complex Double)+constantC = constantAux cconstantC+foreign import ccall "auxi.h constantC"+    cconstantC :: Ptr (Complex Double) -> TCV -- Complex Double :> IO Int++{- | creates a vector with a given number of equal components:++@> constant 2 7+7 |> [2.0,2.0,2.0,2.0,2.0,2.0,2.0]@+-}+constant :: Element a => a -> Int -> Vector a+constant = constantD++--------------------------------------------------------------------------++-- | obtains the complex conjugate of a complex vector+conj :: Vector (Complex Double) -> Vector (Complex Double)+conj v = asComplex $ flatten $ reshape 2 (asReal v) `multiply` diag (fromList [1,-1])++-- | creates a complex vector from vectors with real and imaginary parts+toComplex :: (Vector Double, Vector Double) ->  Vector (Complex Double)+toComplex (r,i) = asComplex $ flatten $ fromColumns [r,i]++-- | the inverse of 'toComplex'+fromComplex :: Vector (Complex Double) -> (Vector Double, Vector Double)+fromComplex z = (r,i) where+    [r,i] = toColumns $ reshape 2 $ asReal z++-- | converts a real vector into a complex representation (with zero imaginary parts)+comp :: Vector Double -> Vector (Complex Double)+comp v = toComplex (v,constant 0 (dim v))++-- | loads a matrix efficiently from formatted ASCII text file (the number of rows and columns must be known in advance).+fromFile :: FilePath -> (Int,Int) -> IO (Matrix Double)+fromFile filename (r,c) = do+    charname <- newCString filename+    res <- createMatrix RowMajor r c+    app1 (c_gslReadMatrix charname) mat res "gslReadMatrix"+    --free charname  -- TO DO: free the auxiliary CString+    return res+foreign import ccall "auxi.h matrix_fscanf" c_gslReadMatrix:: Ptr CChar -> TM++-------------------------------------------------------------------------++-- Generic definitions++{-+transL m = matrixFromVector RowMajor (rows m) $ transdata (cols m) (cdat m) (rows m)++subMatrixG (r0,c0) (rt,ct) x = matrixFromVector RowMajor ct $ fromList $ concat $ map (subList c0 ct) (subList r0 rt (toLists x))+    where subList s n = take n . drop s++diagG v = matrixFromVector RowMajor c $ fromList $ [ l!!(i-1) * delta k i | k <- [1..c], i <- [1..c]]+    where c = dim v+          l = toList v+          delta i j | i==j      = 1+                    | otherwise = 0+-}++transdataG c1 d _ = fromList . concat . transpose . partit c1 . toList $ d++dotL a b = sum (zipWith (*) a b)++multiplyG a b = matrixFromVector RowMajor (cols b) $ fromList $ concat $ multiplyL (toLists a) (toLists b)++multiplyL a b | ok = [[dotL x y | y <- transpose b] | x <- a]+              | otherwise = error "inconsistent dimensions in contraction "+    where ok = case common length a of+                   Nothing -> False+                   Just c  -> c == length b
+ lib/Data/Packed/Internal/Vector.hs view
@@ -0,0 +1,157 @@+{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Packed.Internal.Vector+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable (uses FFI)+--+-- Vector implementation+--+-----------------------------------------------------------------------------+-- #hide++module Data.Packed.Internal.Vector where++import Data.Packed.Internal.Common+import Foreign+import Complex+import Control.Monad(when)++-- | A one-dimensional array of objects stored in a contiguous memory block.+data Vector t = V { dim  :: Int              -- ^ number of elements+                  , fptr :: ForeignPtr t     -- ^ foreign pointer to the memory block+                  }++--ptr (V _ fptr) = unsafeForeignPtrToPtr fptr++-- | signature of foreign functions admitting C-style vectors+type Vc t s = Int -> Ptr t -> s+-- not yet admitted by my haddock version+-- infixr 5 :>+-- type t :> s = Vc t s+++vec = withVector++withVector (V n fp) f = withForeignPtr fp $ \p -> do+    let v g = do+        g n p+    f v++-- | allocates memory for a new vector+createVector :: Storable a => Int -> IO (Vector a)+createVector n = do+    when (n <= 0) $ error ("trying to createVector of dim "++show n)+    fp <- mallocForeignPtrArray n+    return $ V n fp++{- | creates a Vector from a list:++@> fromList [2,3,5,7]+4 |> [2.0,3.0,5.0,7.0]@++-}+fromList :: Storable a => [a] -> Vector a+fromList l = unsafePerformIO $ do+    v <- createVector (length l)+    let f _ p = pokeArray p l >> return 0+    app1 f vec v "fromList"+    return v++safeRead v = unsafePerformIO . withForeignPtr (fptr v)++{- | extracts the Vector elements to a list++@> toList (linspace 5 (1,10))+[1.0,3.25,5.5,7.75,10.0]@++-}+toList :: Storable a => Vector a -> [a]+toList v = safeRead v $ peekArray (dim v)++-- | an alternative to 'fromList' with explicit dimension, used also in the instances for Show (Vector a).+(|>) :: (Storable a) => Int -> [a] -> Vector a+infixl 9 |>+n |> l = if length l == n then fromList l else error "|> with wrong size"++-- | access to Vector elements without range checking+at' :: Storable a => Vector a -> Int -> a+at' v n = safeRead v $ flip peekElemOff n++-- | access to Vector elements with range checking.+at :: Storable a => Vector a -> Int -> a+at v n | n >= 0 && n < dim v = at' v n+       | otherwise          = error "vector index out of range"++{- | takes a number of consecutive elements from a Vector++@> subVector 2 3 (fromList [1..10])+3 |> [3.0,4.0,5.0]@++-}+subVector :: Storable t => Int       -- ^ index of the starting element+                        -> Int       -- ^ number of elements to extract+                        -> Vector t  -- ^ source+                        -> Vector t  -- ^ result+subVector k l (v@V {dim=n})+    | k<0 || k >= n || k+l > n || l < 0 = error "subVector out of range"+    | otherwise = unsafePerformIO $ do+        r <- createVector l+        let f _ s _ d = copyArray d (advancePtr s k) l >> return 0+        app2 f vec v vec r "subVector"+        return r++{- | Reads a vector position:++@> fromList [0..9] \@\> 7+7.0@++-}+(@>) :: Storable t => Vector t -> Int -> t+infixl 9 @>+(@>) = at+++{- | creates a new Vector by joining a list of Vectors++@> join [fromList [1..5], constant 1 3]+8 |> [1.0,2.0,3.0,4.0,5.0,1.0,1.0,1.0]@++-}+join :: Storable t => [Vector t] -> Vector t+join [] = error "joining zero vectors"+join as = unsafePerformIO $ do+    let tot = sum (map dim as)+    r@V {fptr = p} <- createVector tot+    withForeignPtr p $ \ptr ->+        joiner as tot ptr+    return r+  where joiner [] _ _ = return ()+        joiner (V {dim = n, fptr = b} : cs) _ p = do+            withForeignPtr b $ \pb -> copyArray p pb n+            joiner cs 0 (advancePtr p n)+++-- | transforms a complex vector into a real vector with alternating real and imaginary parts +asReal :: Vector (Complex Double) -> Vector Double+asReal v = V { dim = 2*dim v, fptr =  castForeignPtr (fptr v) }++-- | transforms a real vector into a complex vector with alternating real and imaginary parts+asComplex :: Vector Double -> Vector (Complex Double)+asComplex v = V { dim = dim v `div` 2, fptr =  castForeignPtr (fptr v) }++----------------------------------------------------------------++-- | map on Vectors+liftVector :: (Storable a, Storable b) => (a-> b) -> Vector a -> Vector b+liftVector  f = fromList . map f . toList++-- | zipWith for Vectors+liftVector2 :: (Storable a, Storable b, Storable c) => (a-> b -> c) -> Vector a -> Vector b -> Vector c+liftVector2 f u v = fromList $ zipWith f (toList u) (toList v)++-----------------------------------------------------------------
+ lib/Data/Packed/Internal/auxi.c view
@@ -0,0 +1,217 @@+#include "auxi.h"+#include <gsl/gsl_blas.h>+#include <gsl/gsl_linalg.h>+#include <gsl/gsl_matrix.h>+#include <gsl/gsl_math.h>+#include <gsl/gsl_errno.h>+#include <gsl/gsl_fft_complex.h>+#include <gsl/gsl_eigen.h>+#include <gsl/gsl_integration.h>+#include <gsl/gsl_deriv.h>+#include <gsl/gsl_poly.h>+#include <gsl/gsl_multimin.h>+#include <gsl/gsl_complex.h>+#include <gsl/gsl_complex_math.h>+#include <string.h>+#include <stdio.h>++#define MACRO(B) do {B} while (0)+#define ERROR(CODE) MACRO(return CODE;)+#define REQUIRES(COND, CODE) MACRO(if(!(COND)) {ERROR(CODE);})+#define OK return 0;++#define MIN(A,B) ((A)<(B)?(A):(B))+#define MAX(A,B) ((A)>(B)?(A):(B))++#ifdef DBG+#define DEBUGMSG(M) printf("*** calling aux C function: %s\n",M);+#else+#define DEBUGMSG(M)+#endif++#define CHECK(RES,CODE) MACRO(if(RES) return CODE;)++#ifdef DBG+#define DEBUGMAT(MSG,X) printf(MSG" = \n"); gsl_matrix_fprintf(stdout,X,"%f"); printf("\n");+#else+#define DEBUGMAT(MSG,X)+#endif++#ifdef DBG+#define DEBUGVEC(MSG,X) printf(MSG" = \n"); gsl_vector_fprintf(stdout,X,"%f"); printf("\n");+#else+#define DEBUGVEC(MSG,X)+#endif++#define DVVIEW(A) gsl_vector_view A = gsl_vector_view_array(A##p,A##n)+#define DMVIEW(A) gsl_matrix_view A = gsl_matrix_view_array(A##p,A##r,A##c)+#define CVVIEW(A) gsl_vector_complex_view A = gsl_vector_complex_view_array((double*)A##p,A##n)+#define CMVIEW(A) gsl_matrix_complex_view A = gsl_matrix_complex_view_array((double*)A##p,A##r,A##c)+#define KDVVIEW(A) gsl_vector_const_view A = gsl_vector_const_view_array(A##p,A##n)+#define KDMVIEW(A) gsl_matrix_const_view A = gsl_matrix_const_view_array(A##p,A##r,A##c)+#define KCVVIEW(A) gsl_vector_complex_const_view A = gsl_vector_complex_const_view_array((double*)A##p,A##n)+#define KCMVIEW(A) gsl_matrix_complex_const_view A = gsl_matrix_complex_const_view_array((double*)A##p,A##r,A##c)++#define V(a) (&a.vector)+#define M(a) (&a.matrix)++#define GCVEC(A) int A##n, gsl_complex*A##p+#define KGCVEC(A) int A##n, const gsl_complex*A##p++#define BAD_SIZE 2000+#define BAD_CODE 2001+#define MEM      2002+#define BAD_FILE 2003++int transR(KRMAT(x),RMAT(t)) {+    REQUIRES(xr==tc && xc==tr,BAD_SIZE);+    DEBUGMSG("transR");+    KDMVIEW(x);+    DMVIEW(t);+    int res = gsl_matrix_transpose_memcpy(M(t),M(x));+    CHECK(res,res);+    OK+}++int transC(KCMAT(x),CMAT(t)) {+    REQUIRES(xr==tc && xc==tr,BAD_SIZE);+    DEBUGMSG("transC");+    KCMVIEW(x);+    CMVIEW(t);+    int res = gsl_matrix_complex_transpose_memcpy(M(t),M(x));+    CHECK(res,res);+    OK+}+++int submatrixR(int r1, int r2, int c1, int c2, KRMAT(x),RMAT(r)) {+    REQUIRES(0<=r1 && r1<=r2 && r2<xr && 0<=c1 && c1<=c2 && c2<xc &&+            rr==r2-r1+1 && rc==c2-c1+1,BAD_SIZE);+    DEBUGMSG("submatrixR");+    KDMVIEW(x);+    DMVIEW(r);+    gsl_matrix_const_view S = gsl_matrix_const_submatrix(M(x),r1,c1,rr,rc);+    int res = gsl_matrix_memcpy(M(r),M(S));+    CHECK(res,res);+    OK+}+++int constantR(double * pval, RVEC(r)) {+    DEBUGMSG("constantR")+    int k;+    double val = *pval;+    for(k=0;k<rn;k++) {+        rp[k]=val;+    }+    OK+}++int constantC(gsl_complex* pval, CVEC(r)) {+    DEBUGMSG("constantC")+    int k;+    gsl_complex val = *pval;+    for(k=0;k<rn;k++) {+        rp[k]=val;+    }+    OK+}+++int multiplyR(int ta, KRMAT(a), int tb, KRMAT(b),RMAT(r)) {+    //printf("%d %d %d %d %d %d\n",ar,ac,br,bc,rr,rc);+    //REQUIRES(ac==br && ar==rr && bc==rc,BAD_SIZE);+    DEBUGMSG("multiplyR (gsl_blas_dgemm)");+    KDMVIEW(a);+    KDMVIEW(b);+    DMVIEW(r);+    int k;+    for(k=0;k<rr*rc;k++) rp[k]=0;+    int debug = 0;+    if(debug) {+        printf("---------------------------\n");+        printf("%p: ",ap); for(k=0;k<ar*ac;k++) printf("%f ",ap[k]); printf("\n");+        printf("%p: ",bp); for(k=0;k<br*bc;k++) printf("%f ",bp[k]); printf("\n");+        printf("%p: ",rp); for(k=0;k<rr*rc;k++) printf("%f ",rp[k]); printf("\n");+    }+    int res = gsl_blas_dgemm(+         ta?CblasTrans:CblasNoTrans,+         tb?CblasTrans:CblasNoTrans,+         1.0, M(a), M(b),+         0.0, M(r));+    if(debug) {+        printf("--------------\n");+        printf("%p: ",ap); for(k=0;k<ar*ac;k++) printf("%f ",ap[k]); printf("\n");+        printf("%p: ",bp); for(k=0;k<br*bc;k++) printf("%f ",bp[k]); printf("\n");+        printf("%p: ",rp); for(k=0;k<rr*rc;k++) printf("%f ",rp[k]); printf("\n");+    }+    CHECK(res,res);+    OK+}++int multiplyC(int ta, KCMAT(a), int tb, KCMAT(b),CMAT(r)) {+    //REQUIRES(ac==br && ar==rr && bc==rc,BAD_SIZE);+    DEBUGMSG("multiplyC (gsl_blas_zgemm)");+    KCMVIEW(a);+    KCMVIEW(b);+    CMVIEW(r);+    int k;+    gsl_complex alpha, beta;+    GSL_SET_COMPLEX(&alpha,1.,0.);+    GSL_SET_COMPLEX(&beta,0.,0.);+    //double *TEMP = (double*)malloc(rr*rc*2*sizeof(double));+    //gsl_matrix_complex_view T = gsl_matrix_complex_view_array(TEMP,rr,rc);+    for(k=0;k<rr*rc;k++) rp[k]=beta;+    //for(k=0;k<2*rr*rc;k++) TEMP[k]=0;+    int debug = 0;+    if(debug) {+        printf("---------------------------\n");+        printf("%p: ",ap); for(k=0;k<2*ar*ac;k++) printf("%f ",((double*)ap)[k]); printf("\n");+        printf("%p: ",bp); for(k=0;k<2*br*bc;k++) printf("%f ",((double*)bp)[k]); printf("\n");+        printf("%p: ",rp); for(k=0;k<2*rr*rc;k++) printf("%f ",((double*)rp)[k]); printf("\n");+        //printf("%p: ",T); for(k=0;k<2*rr*rc;k++) printf("%f ",TEMP[k]); printf("\n");+    }+    int res = gsl_blas_zgemm(+         ta?CblasTrans:CblasNoTrans,+         tb?CblasTrans:CblasNoTrans,+         alpha, M(a), M(b),+         beta, M(r)); +         //&T.matrix);+    //memcpy(rp,TEMP,2*rr*rc*sizeof(double));+    if(debug) {+        printf("--------------\n");+        printf("%p: ",ap); for(k=0;k<2*ar*ac;k++) printf("%f ",((double*)ap)[k]); printf("\n");+        printf("%p: ",bp); for(k=0;k<2*br*bc;k++) printf("%f ",((double*)bp)[k]); printf("\n");+        printf("%p: ",rp); for(k=0;k<2*rr*rc;k++) printf("%f ",((double*)rp)[k]); printf("\n");+        //printf("%p: ",T); for(k=0;k<2*rr*rc;k++) printf("%f ",TEMP[k]); printf("\n");+    }+    CHECK(res,res);+    OK+}+++int diagR(KRVEC(d),RMAT(r)) {+    REQUIRES(dn==rr && rr==rc,BAD_SIZE);+    DEBUGMSG("diagR");+    int i,j;+    for (i=0;i<rr;i++) {+        for(j=0;j<rc;j++) {+            rp[i*rc+j] = i==j?dp[i]:0.;+        }+    }+    OK+}++int diagC(KCVEC(d),CMAT(r)) {+    REQUIRES(dn==rr && rr==rc,BAD_SIZE);+    DEBUGMSG("diagC");+    int i,j;+    gsl_complex zero;+    GSL_SET_COMPLEX(&zero,0.,0.);+    for (i=0;i<rr;i++) {+        for(j=0;j<rc;j++) {+            rp[i*rc+j] = i==j?dp[i]:zero;+        }+    }+    OK+}
+ lib/Data/Packed/Internal/auxi.h view
@@ -0,0 +1,30 @@+#include <gsl/gsl_complex.h>++#define RVEC(A) int A##n, double*A##p+#define RMAT(A) int A##r, int A##c, double* A##p+#define KRVEC(A) int A##n, const double*A##p+#define KRMAT(A) int A##r, int A##c, const double* A##p++#define CVEC(A) int A##n, gsl_complex*A##p+#define CMAT(A) int A##r, int A##c, gsl_complex* A##p+#define KCVEC(A) int A##n, const gsl_complex*A##p+#define KCMAT(A) int A##r, int A##c, const gsl_complex* A##p+++int transR(KRMAT(x),RMAT(t));+int transC(KCMAT(x),CMAT(t));++int constantR(double *val     , RVEC(r));+int constantC(gsl_complex *val, CVEC(r));++int multiplyR(int ta, KRMAT(a), int tb,  KRMAT(b),RMAT(r));+int multiplyC(int ta, KCMAT(a), int tb, KCMAT(b),CMAT(r));++int submatrixR(int r1, int r2, int c1, int c2, KRMAT(x),RMAT(r));++int diagR(KRVEC(d),RMAT(r));+int diagC(KCVEC(d),CMAT(r));++const char * gsl_strerror (const int gsl_errno);++int matrix_fscanf(char*filename, RMAT(a));
+ lib/Data/Packed/Matrix.hs view
@@ -0,0 +1,229 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Packed.Matrix+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable+--+-- A Matrix representation suitable for numerical computations using LAPACK and GSL.+--+-----------------------------------------------------------------------------++module Data.Packed.Matrix (+    Element,+    Matrix,rows,cols,+    (><),+    trans,+    reshape, flatten,+    fromLists, toLists,+    (@@>),+    asRow, asColumn,+    fromRows, toRows, fromColumns, toColumns,+    fromBlocks, repmat,+    flipud, fliprl,+    subMatrix, takeRows, dropRows, takeColumns, dropColumns,+    extractRows,+    ident, diag, diagRect, takeDiag,+    liftMatrix, liftMatrix2,+    format, readMatrix, fromFile, fromArray2D+) where++import Data.Packed.Internal+import Data.Packed.Vector+import Data.List(transpose,intersperse)+import Data.Array++-- | creates a matrix from a vertical list of matrices+joinVert :: Element t => [Matrix t] -> Matrix t+joinVert ms = case common cols ms of+    Nothing -> error "joinVert on matrices with different number of columns"+    Just c  -> reshape c $ join (map flatten ms)++-- | creates a matrix from a horizontal list of matrices+joinHoriz :: Element t => [Matrix t] -> Matrix t+joinHoriz ms = trans. joinVert . map trans $ ms++{- | Creates a matrix from blocks given as a list of lists of matrices:++@\> let a = 'diag' $ 'fromList' [5,7,2]+\> let b = 'reshape' 4 $ 'constant' (-1) 12+\> fromBlocks [[a,b],[b,a]]+(6><7)+ [  5.0,  0.0,  0.0, -1.0, -1.0, -1.0, -1.0+ ,  0.0,  7.0,  0.0, -1.0, -1.0, -1.0, -1.0+ ,  0.0,  0.0,  2.0, -1.0, -1.0, -1.0, -1.0+ , -1.0, -1.0, -1.0, -1.0,  5.0,  0.0,  0.0+ , -1.0, -1.0, -1.0, -1.0,  0.0,  7.0,  0.0+ , -1.0, -1.0, -1.0, -1.0,  0.0,  0.0,  2.0 ]@+-}+fromBlocks :: Element t => [[Matrix t]] -> Matrix t+fromBlocks = joinVert . map joinHoriz ++-- | Reverse rows +flipud :: Element t => Matrix t -> Matrix t+flipud m = fromRows . reverse . toRows $ m++-- | Reverse columns+fliprl :: Element t => Matrix t -> Matrix t+fliprl m = fromColumns . reverse . toColumns $ m++------------------------------------------------------------++{- | creates a rectangular diagonal matrix++@> diagRect (constant 5 3) 3 4+(3><4)+ [ 5.0, 0.0, 0.0, 0.0+ , 0.0, 5.0, 0.0, 0.0+ , 0.0, 0.0, 5.0, 0.0 ]@+-}+diagRect :: (Element t, Num t) => Vector t -> Int -> Int -> Matrix t+diagRect s r c+    | dim s < min r c = error "diagRect"+    | r == c    = diag s+    | r < c     = trans $ diagRect s c r+    | otherwise = joinVert  [diag s , zeros (r-c,c)]+    where zeros (r',c') = reshape c' $ constantD 0 (r'*c')++-- | extracts the diagonal from a rectangular matrix+takeDiag :: (Element t) => Matrix t -> Vector t+takeDiag m = fromList [flatten m `at` (k*cols m+k) | k <- [0 .. min (rows m) (cols m) -1]]++-- | creates the identity matrix of given dimension+ident :: Element a => Int -> Matrix a+ident n = diag (constant 1 n)++------------------------------------------------------------++{- | An easy way to create a matrix:++@\> (2><3)[1..6]+(2><3)+ [ 1.0, 2.0, 3.0+ , 4.0, 5.0, 6.0 ]@++This is the format produced by the instances of Show (Matrix a), which+can also be used for input.+-}+(><) :: (Element a) => Int -> Int -> [a] -> Matrix a+r >< c = f where+    f l | dim v == r*c = matrixFromVector RowMajor c v+        | otherwise    = error $ "inconsistent list size = "+                                 ++show (dim v) ++" in ("++show r++"><"++show c++")"+        where v = fromList l++----------------------------------------------------------------++-- | Creates a matrix with the first n rows of another matrix+takeRows :: Element t => Int -> Matrix t -> Matrix t+takeRows n mt = subMatrix (0,0) (n, cols mt) mt+-- | Creates a copy of a matrix without the first n rows+dropRows :: Element t => Int -> Matrix t -> Matrix t+dropRows n mt = subMatrix (n,0) (rows mt - n, cols mt) mt+-- |Creates a matrix with the first n columns of another matrix+takeColumns :: Element t => Int -> Matrix t -> Matrix t+takeColumns n mt = subMatrix (0,0) (rows mt, n) mt+-- | Creates a copy of a matrix without the first n columns+dropColumns :: Element t => Int -> Matrix t -> Matrix t+dropColumns n mt = subMatrix (0,n) (rows mt, cols mt - n) mt++----------------------------------------------------------------++{- | Creates a 'Matrix' from a list of lists (considered as rows).++@\> fromLists [[1,2],[3,4],[5,6]]+(3><2)+ [ 1.0, 2.0+ , 3.0, 4.0+ , 5.0, 6.0 ]@+-}+fromLists :: Element t => [[t]] -> Matrix t+fromLists = fromRows . map fromList++-- | creates a 1-row matrix from a vector+asRow :: Element a => Vector a -> Matrix a+asRow v = reshape (dim v) v++-- | creates a 1-column matrix from a vector+asColumn :: Element a => Vector a -> Matrix a+asColumn v = reshape 1 v++-----------------------------------------------------++fromArray2D :: (Element e) => Array (Int, Int) e -> Matrix e+fromArray2D m = (r><c) (elems m)+    where ((r0,c0),(r1,c1)) = bounds m+          r = r1-r0+1+          c = c1-c0+1++------------------------------------------------------+{-+-- shows a Double with n digits after the decimal point    +shf :: (RealFloat a) => Int -> a -> String     +shf dec n | abs n < 1e-10 = "0."+          | abs (n - (fromIntegral.round $ n)) < 1e-10 = show (round n) ++"."+          | otherwise = showGFloat (Just dec) n ""    +-- shows a Complex Double as a pair, with n digits after the decimal point    +shfc n z@ (a:+b) +    | magnitude z <1e-10 = "0."+    | abs b < 1e-10 = shf n a+    | abs a < 1e-10 = shf n b ++"i"+    | b > 0         = shf n a ++"+"++shf n b ++"i"+    | otherwise     = shf n a ++shf n b ++"i"         ++-}++dsp' :: String -> [[String]] -> String+dsp' sep as = unlines . map unwords' $ transpose mtp where +    mt = transpose as+    longs = map (maximum . map length) mt+    mtp = zipWith (\a b -> map (pad a) b) longs mt+    pad n str = replicate (n - length str) ' ' ++ str+    unwords' = concat . intersperse sep++{- | Creates a string from a matrix given a separator and a function to show each entry. Using+this function the user can easily define any desired display function:++@import Text.Printf(printf)@++@disp = putStrLn . format \"  \" (printf \"%.2f\")@++-}+format :: (Element t) => String -> (t -> String) -> Matrix t -> String+format sep f m = dsp' sep . map (map f) . toLists $ m++{-+disp m f = putStrLn $ "matrix ("++show (rows m) ++"x"++ show (cols m) ++")\n"++format " | " f m++dispR :: Int -> Matrix Double -> IO ()+dispR d m = disp m (shf d)++dispC :: Int -> Matrix (Complex Double) -> IO ()+dispC d m = disp m (shfc d)+-}++-- | creates a matrix from a table of numbers.+readMatrix :: String -> Matrix Double+readMatrix = fromLists . map (map read). map words . filter (not.null) . lines++-- | rearranges the rows of a matrix according to the order given in a list of integers. +extractRows :: Element t => [Int] -> Matrix t -> Matrix t+extractRows l m = fromRows $ extract (toRows $ m) l+    where extract l' is = [l'!!i |i<-is]++{- | creates matrix by repetition of a matrix a given number of rows and columns++@> repmat (ident 2) 2 3 :: Matrix Double+(4><6)+ [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0+ , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0+ , 1.0, 0.0, 1.0, 0.0, 1.0, 0.0+ , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0 ]@++-}+repmat :: (Element t) => Matrix t -> Int -> Int -> Matrix t+repmat m r c = fromBlocks $ partit c $ replicate (r*c) m
+ lib/Data/Packed/Vector.hs view
@@ -0,0 +1,49 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Packed.Vector+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable+--+-- A representation of 1D arrays suitable for numeric computations using external libraries.+--+-----------------------------------------------------------------------------++module Data.Packed.Vector (+    Vector,+    fromList, (|>), toList,+    dim, (@>),+    subVector, join,+    constant, linspace,+    vectorMax, vectorMin, vectorMaxIndex, vectorMinIndex,+    liftVector, liftVector2+) where++import Data.Packed.Internal+import Numeric.GSL.Vector++{- | Creates a real vector containing a range of values:++@\> linspace 5 (-3,7)+5 |> [-3.0,-0.5,2.0,4.5,7.0]@+-}+linspace :: Int -> (Double, Double) -> Vector Double+linspace n (a,b) = add a $ scale s  $ fromList [0 .. fromIntegral n-1]+    where scale = vectorMapValR Scale+          add   = vectorMapValR AddConstant+          s = (b-a)/fromIntegral (n-1)++vectorMax :: Vector Double -> Double+vectorMax = toScalarR Max++vectorMin :: Vector Double -> Double+vectorMin = toScalarR Min++vectorMaxIndex :: Vector Double -> Int+vectorMaxIndex = round . toScalarR MaxIdx++vectorMinIndex :: Vector Double -> Int+vectorMinIndex = round . toScalarR MinIdx
+ lib/Graphics/Plot.hs view
@@ -0,0 +1,167 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Graphics.Plot+-- Copyright   :  (c) Alberto Ruiz 2005+-- License     :  GPL-style+-- +-- Maintainer  :  Alberto Ruiz (aruiz at um dot es)+-- Stability   :  provisional+-- Portability :  uses gnuplot and ImageMagick+--+-- Very basic (and provisional) drawing tools using gnuplot and imageMagick.+--+-----------------------------------------------------------------------------++module Graphics.Plot(++    mplot,++    plot, parametricPlot, ++    splot, mesh, mesh', meshdom,++    matrixToPGM, imshow,++    gnuplotX++) where++import Data.Packed.Vector+import Data.Packed.Matrix+import Numeric.LinearAlgebra.Linear(outer)+import Numeric.GSL.Vector(FunCodeS(Max,Min),toScalarR)+import Data.List(intersperse)+import System+import Foreign hiding (rotate)+++size = dim++-- | Loads a real matrix from a formatted ASCII text file +--fromFile :: FilePath -> IO Matrix+--fromFile filename = readFile filename >>= return . readMatrix read++-- | Saves a real matrix to a formatted ascii text file+toFile :: FilePath -> Matrix Double -> IO ()+toFile filename matrix = writeFile filename (unlines . map unwords. map (map show) . toLists $ matrix)++------------------------------------------------------------------------+++-- | From vectors x and y, it generates a pair of matrices to be used as x and y arguments for matrix functions.+meshdom :: Vector Double -> Vector Double -> (Matrix Double , Matrix Double)+meshdom r1 r2 = (outer r1 (constant 1 (size r2)), outer (constant 1 (size r1)) r2)++gnuplotX :: String -> IO ()+gnuplotX command = do {system cmdstr; return()} where+    cmdstr = "echo \""++command++"\" | gnuplot -persist"++datafollows = "\\\"-\\\""++prep = (++"e\n\n") . unlines . map (unwords . (map show))+++{- | Draws a 3D surface representation of a real matrix.++> > mesh (hilb 20)++In certain versions you can interactively rotate the graphic using the mouse.++-}+mesh :: Matrix Double -> IO ()+mesh m = gnuplotX (command++dat) where+    command = "splot "++datafollows++" matrix with lines\n"+    dat = prep $ toLists $ m++mesh' :: Matrix Double -> IO ()+mesh' m = do+    writeFile "splot-gnu-command" "splot \"splot-tmp.txt\" matrix with lines; pause -1"; +    toFile "splot-tmp.txt" m+    putStr "Press [Return] to close the graphic and continue... "+    system "gnuplot -persist splot-gnu-command"+    system "rm splot-tmp.txt splot-gnu-command"+    return ()++{- | Draws the surface represented by the function f in the desired ranges and number of points, internally using 'mesh'.++> > let f x y = cos (x + y) +> > splot f (0,pi) (0,2*pi) 50    ++-}+splot :: (Matrix Double->Matrix Double->Matrix Double) -> (Double,Double) -> (Double,Double) -> Int -> IO () +splot f rx ry n = mesh' z where+    (x,y) = meshdom (linspace n rx) (linspace n ry)+    z = f x y++{- | plots several vectors against the first one -}+mplot :: [Vector Double] -> IO ()+mplot m = gnuplotX (commands++dats) where+    commands = if length m == 1 then command1 else commandmore+    command1 = "plot "++datafollows++" with lines\n" ++ dat+    commandmore = "plot " ++ plots ++ "\n"+    plots = concat $ intersperse ", " (map cmd [2 .. length m])+    cmd k = datafollows++" using 1:"++show k++" with lines"+    dat = prep $ toLists $ fromColumns m+    dats = concat (replicate (length m-1) dat)+++{-+mplot' m = do+    writeFile "plot-gnu-command" (commands++endcmd)+    toFile "plot-tmp.txt" (fromColumns m)+    putStr "Press [Return] to close the graphic and continue... "+    system "gnuplot plot-gnu-command"+    system "rm plot-tmp.txt plot-gnu-command"+    return ()+ where+    commands = if length m == 1 then command1 else commandmore+    command1 = "plot \"plot-tmp.txt\" with lines\n"+    commandmore = "plot " ++ plots ++ "\n"+    plots = concat $ intersperse ", " (map cmd [2 .. length m])+    cmd k = "\"plot-tmp.txt\" using 1:"++show k++" with lines"+    endcmd = "pause -1"+-}++-- apply several functions to one object+mapf fs x = map ($ x) fs++{- | Draws a list of functions over a desired range and with a desired number of points ++> > plot [sin, cos, sin.(3*)] (0,2*pi) 1000++-}+plot :: [Vector Double->Vector Double] -> (Double,Double) -> Int -> IO ()+plot fs rx n = mplot (x: mapf fs x)+    where x = linspace n rx  ++{- | Draws a parametric curve. For instance, to draw a spiral we can do something like:++> > parametricPlot (\t->(t * sin t, t * cos t)) (0,10*pi) 1000++-}+parametricPlot :: (Vector Double->(Vector Double,Vector Double)) -> (Double, Double) -> Int -> IO ()+parametricPlot f rt n = mplot [fx, fy]+    where t = linspace n rt+          (fx,fy) = f t+++-- | writes a matrix to pgm image file+matrixToPGM :: Matrix Double -> String+matrixToPGM m = header ++ unlines (map unwords ll) where+    c = cols m+    r = rows m+    header = "P2 "++show c++" "++show r++" "++show (round maxgray :: Int)++"\n"+    maxgray = 255.0+    maxval = toScalarR Max $ flatten $ m+    minval = toScalarR Min $ flatten $ m+    scale = if (maxval == minval) +        then 0.0+        else maxgray / (maxval - minval)+    f x = show ( round ( scale *(x - minval) ) :: Int )+    ll = map (map f) (toLists m)++-- | imshow shows a representation of a matrix as a gray level image using ImageMagick's display.+imshow :: Matrix Double -> IO ()+imshow m = do+    system $ "echo \""++ matrixToPGM m ++"\"| display -antialias -resize 300 - &"+    return ()
+ lib/Numeric/GSL.hs view
@@ -0,0 +1,38 @@+{- |++Module      :  Numeric.GSL+Copyright   :  (c) Alberto Ruiz 2006-7+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses -fffi and -fglasgow-exts++This module reexports all the available GSL functions (except those in "Numeric.LinearAlgebra").++-}++module Numeric.GSL (+  module Numeric.GSL.Integration+, module Numeric.GSL.Differentiation+, module Numeric.GSL.Fourier+, module Numeric.GSL.Polynomials+, module Numeric.GSL.Minimization+, module Numeric.GSL.Special+, module Complex+, setErrorHandlerOff+) where++import Numeric.GSL.Integration+import Numeric.GSL.Differentiation+import Numeric.GSL.Special+import Numeric.GSL.Fourier+import Numeric.GSL.Polynomials+import Numeric.GSL.Minimization+import Complex+import Numeric.GSL.Special+++-- | This action removes the GSL default error handler (which aborts the program), so that+-- GSL errors can be handled by Haskell (using Control.Exception) and ghci doesn't abort.+foreign import ccall "GSL/gsl-aux.h no_abort_on_error" setErrorHandlerOff :: IO ()
+ lib/Numeric/GSL/Differentiation.hs view
@@ -0,0 +1,79 @@+{-# OPTIONS  #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Differentiation+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Numerical differentiation.++<http://www.gnu.org/software/gsl/manual/html_node/Numerical-Differentiation.html#Numerical-Differentiation>++From the GSL manual: \"The functions described in this chapter compute numerical derivatives by finite differencing. An adaptive algorithm is used to find the best choice of finite difference and to estimate the error in the derivative.\"+-}+-----------------------------------------------------------------------------+module Numeric.GSL.Differentiation (+    derivCentral,+    derivForward,+    derivBackward+) where++import Foreign+import Data.Packed.Internal(mkfun,check,(//))++derivGen ::+    Int                   -- ^ type: 0 central, 1 forward, 2 backward+    -> Double             -- ^ initial step size+    -> (Double -> Double) -- ^ function+    -> Double             -- ^ point where the derivative is taken+    -> (Double, Double)   -- ^ result and error+derivGen c h f x = unsafePerformIO $ do+    r <- malloc+    e <- malloc+    fp <- mkfun (\y _ -> f y) +    c_deriv c fp x h r e // check "deriv"+    vr <- peek r+    ve <- peek e+    let result = (vr,ve)+    free r+    free e+    freeHaskellFunPtr fp+    return result++foreign import ccall "gsl-aux.h deriv" + c_deriv :: Int -> FunPtr (Double -> Ptr () -> Double) -> Double -> Double +                    -> Ptr Double -> Ptr Double -> IO Int+++{- | Adaptive central difference algorithm, /gsl_deriv_central/. For example:++> > let deriv = derivCentral 0.01 +> > deriv sin (pi/4)+>(0.7071067812000676,1.0600063101654055e-10)+> > cos (pi/4)+>0.7071067811865476 ++-}+derivCentral :: Double                  -- ^ initial step size+                -> (Double -> Double)   -- ^ function +                -> Double               -- ^ point where the derivative is taken+                -> (Double, Double)     -- ^ result and absolute error+derivCentral = derivGen 0++-- | Adaptive forward difference algorithm, /gsl_deriv_forward/. The function is evaluated only at points greater than x, and never at x itself. The derivative is returned in result and an estimate of its absolute error is returned in abserr. This function should be used if f(x) has a discontinuity at x, or is undefined for values less than x. A backward derivative can be obtained using a negative step.+derivForward :: Double                  -- ^ initial step size+                -> (Double -> Double)   -- ^ function +                -> Double               -- ^ point where the derivative is taken+                -> (Double, Double)     -- ^ result and absolute error+derivForward = derivGen 1++-- | Adaptive backward difference algorithm, /gsl_deriv_backward/. +derivBackward ::Double                  -- ^ initial step size+                -> (Double -> Double)   -- ^ function +                -> Double               -- ^ point where the derivative is taken+                -> (Double, Double)     -- ^ result and absolute error+derivBackward = derivGen 2
+ lib/Numeric/GSL/Fourier.hs view
@@ -0,0 +1,46 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+{- |+Module      : Numeric.GSL.Fourier+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Fourier Transform.++<http://www.gnu.org/software/gsl/manual/html_node/Fast-Fourier-Transforms.html#Fast-Fourier-Transforms>++-}+-----------------------------------------------------------------------------+module Numeric.GSL.Fourier (+    fft,+    ifft+) where++import Data.Packed.Internal+import Complex+import Foreign++genfft code v = unsafePerformIO $ do+    r <- createVector (dim v)+    app2 (c_fft code) vec v vec r "fft"+    return r++foreign import ccall "gsl-aux.h fft" c_fft ::  Int -> TCVCV+++{- | Fast 1D Fourier transform of a 'Vector' @(@'Complex' 'Double'@)@ using /gsl_fft_complex_forward/. It uses the same scaling conventions as GNU Octave.++@> fft ('GSL.Matrix.fromList' [1,2,3,4])+vector (4) [10.0 :+ 0.0,(-2.0) :+ 2.0,(-2.0) :+ 0.0,(-2.0) :+ (-2.0)]@++-}+fft :: Vector (Complex Double) -> Vector (Complex Double)+fft = genfft 0++-- | The inverse of 'fft', using /gsl_fft_complex_inverse/.+ifft :: Vector (Complex Double) -> Vector (Complex Double)+ifft = genfft 1
+ lib/Numeric/GSL/Integration.hs view
@@ -0,0 +1,90 @@+{-# OPTIONS #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Integration+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Numerical integration routines.++<http://www.gnu.org/software/gsl/manual/html_node/Numerical-Integration.html#Numerical-Integration>+-}+-----------------------------------------------------------------------------++module Numeric.GSL.Integration (+    integrateQNG,+    integrateQAGS+) where++import Foreign+import Data.Packed.Internal(mkfun,check,(//))+++--------------------------------------------------------------------+{- | Numerical integration using /gsl_integration_qags/ (adaptive integration with singularities). For example:++@\> let quad = integrateQAGS 1E-9 1000 +\> let f a x = x**(-0.5) * log (a*x)+\> quad (f 1) 0 1+(-3.999999999999974,4.871658632055187e-13)@+ +-}++integrateQAGS :: Double               -- ^ precision (e.g. 1E-9)+                 -> Int               -- ^ size of auxiliary workspace (e.g. 1000)+                 -> (Double -> Double) -- ^ function to be integrated on the interval (a,b)+                 -> Double           -- ^ a+                 -> Double           -- ^ b+                 -> (Double, Double) -- ^ result of the integration and error+integrateQAGS prec n f a b = unsafePerformIO $ do+    r <- malloc+    e <- malloc+    fp <- mkfun (\x _ -> f x) +    c_integrate_qags fp a b prec n r e // check "integrate_qags"+    vr <- peek r+    ve <- peek e+    let result = (vr,ve)+    free r+    free e+    freeHaskellFunPtr fp+    return result++foreign import ccall "gsl-aux.h integrate_qags" + c_integrate_qags :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> Double -> Int +                     -> Ptr Double -> Ptr Double -> IO Int++-----------------------------------------------------------------+{- | Numerical integration using /gsl_integration_qng/ (useful for fast integration of smooth functions). For example:++@\> let quad = integrateQNG 1E-6 +\> quad (\\x -> 4\/(1+x*x)) 0 1 +(3.141592653589793,3.487868498008632e-14)@+ +-}++integrateQNG :: Double               -- ^ precision (e.g. 1E-9)+                 -> (Double -> Double) -- ^ function to be integrated on the interval (a,b)+                 -> Double           -- ^ a+                 -> Double           -- ^ b+                 -> (Double, Double) -- ^ result of the integration and error+integrateQNG prec f a b = unsafePerformIO $ do+    r <- malloc+    e <- malloc+    fp <- mkfun (\x _ -> f x) +    c_integrate_qng fp a b prec r e  // check "integrate_qng"+    vr <- peek r+    ve <- peek e+    let result = (vr,ve)+    free r+    free e+    freeHaskellFunPtr fp+    return result++foreign import ccall "gsl-aux.h integrate_qng" + c_integrate_qng :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> Double +                    -> Ptr Double -> Ptr Double -> IO Int+
+ lib/Numeric/GSL/Matrix.hs view
@@ -0,0 +1,346 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.GSL.Matrix+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable (uses FFI)+--+-- A few linear algebra computations based on the Numeric.GSL (<http://www.gnu.org/software/Numeric.GSL>).+--+-----------------------------------------------------------------------------+-- #hide++module Numeric.GSL.Matrix(+    eigSg, eigHg,+    svdg,+    qr, qrPacked, unpackQR,+    cholR, cholC,+    luSolveR, luSolveC,+    luR, luC+) where++import Data.Packed.Internal+import Data.Packed.Matrix(ident)+import Numeric.GSL.Vector+import Foreign+import Complex++{- | eigendecomposition of a real symmetric matrix using /gsl_eigen_symmv/.++> > let (l,v) = eigS $ 'fromLists' [[1,2],[2,1]]+> > l+> 3.000 -1.000+>+> > v+> 0.707 -0.707+> 0.707  0.707+>+> > v <> diag l <> trans v+> 1.000 2.000+> 2.000 1.000++-}+eigSg :: Matrix Double -> (Vector Double, Matrix Double)+eigSg = eigSg' . cmat++eigSg' m+    | r == 1 = (fromList [cdat m `at` 0], singleton 1)+    | otherwise = unsafePerformIO $ do+        l <- createVector r+        v <- createMatrix RowMajor r r+        app3 c_eigS mat m vec l mat v "eigSg"+        return (l,v)+  where r = rows m+foreign import ccall "gsl-aux.h eigensystemR" c_eigS :: TMVM++------------------------------------------------------------------++++{- | eigendecomposition of a complex hermitian matrix using /gsl_eigen_hermv/++> > let (l,v) = eigH $ 'fromLists' [[1,2+i],[2-i,3]]+>+> > l+> 4.449 -0.449+>+> > v+>         -0.544          0.839+> (-0.751,0.375) (-0.487,0.243)+>+> > v <> diag l <> (conjTrans) v+>          1.000 (2.000,1.000)+> (2.000,-1.000)         3.000++-}+eigHg :: Matrix (Complex Double)-> (Vector Double, Matrix (Complex Double))+eigHg = eigHg' . cmat++eigHg' m+    | r == 1 = (fromList [realPart $ cdat m `at` 0], singleton 1)+    | otherwise = unsafePerformIO $ do+        l <- createVector r+        v <- createMatrix RowMajor r r+        app3 c_eigH mat m vec l mat v "eigHg"+        return (l,v)+  where r = rows m+foreign import ccall "gsl-aux.h eigensystemC" c_eigH :: TCMVCM+++{- | Singular value decomposition of a real matrix, using /gsl_linalg_SV_decomp_mod/:++@\> let (u,s,v) = svdg $ 'fromLists' [[1,2,3],[-4,1,7]]+\+\> u+0.310 -0.951+0.951  0.310+\+\> s+8.497 2.792+\+\> v+-0.411 -0.785+ 0.185 -0.570+ 0.893 -0.243+\+\> u \<\> 'diag' s \<\> 'trans' v+ 1. 2. 3.+-4. 1. 7.@++-}+svdg :: Matrix Double -> (Matrix Double, Vector Double, Matrix Double)+svdg x = if rows x >= cols x+    then svd' (cmat x)+    else (v, s, u) where (u,s,v) = svd' (cmat (trans x))++svd' x = unsafePerformIO $ do+    u <- createMatrix RowMajor r c+    s <- createVector c+    v <- createMatrix RowMajor c c+    app4 c_svd mat x mat u vec s mat v "svdg"+    return (u,s,v)+  where r = rows x+        c = cols x+foreign import ccall "gsl-aux.h svd" c_svd :: TMMVM++{- | QR decomposition of a real matrix using /gsl_linalg_QR_decomp/ and /gsl_linalg_QR_unpack/.++@\> let (q,r) = qr $ 'fromLists' [[1,3,5,7],[2,0,-2,4]]+\+\> q+-0.447 -0.894+-0.894  0.447+\+\> r+-2.236 -1.342 -0.447 -6.708+    0. -2.683 -5.367 -4.472+\+\> q \<\> r+1.000 3.000  5.000 7.000+2.000    0. -2.000 4.000@++-}+qr :: Matrix Double -> (Matrix Double, Matrix Double)+qr = qr' . cmat++qr' x = unsafePerformIO $ do+    q <- createMatrix RowMajor r r+    rot <- createMatrix RowMajor r c+    app3 c_qr mat x mat q mat rot  "qr"+    return (q,rot)+  where r = rows x+        c = cols x+foreign import ccall "gsl-aux.h QR" c_qr :: TMMM++qrPacked :: Matrix Double -> (Matrix Double, Vector Double)+qrPacked = qrPacked' . cmat++qrPacked' x = unsafePerformIO $ do+    qrp <- createMatrix RowMajor r c+    tau <- createVector (min r c)+    app3 c_qrPacked mat x mat qrp vec tau "qrUnpacked"+    return (qrp,tau)+  where r = rows x+        c = cols x+foreign import ccall "gsl-aux.h QRpacked" c_qrPacked :: TMMV++unpackQR :: (Matrix Double, Vector Double) -> (Matrix Double, Matrix Double)+unpackQR (qrp,tau) = unpackQR' (cmat qrp, tau)++unpackQR' (qrp,tau) = unsafePerformIO $ do+    q <- createMatrix RowMajor r r+    res <- createMatrix RowMajor r c+    app4 c_qrUnpack mat qrp vec tau mat q mat res "qrUnpack"+    return (q,res)+  where r = rows qrp+        c = cols qrp+foreign import ccall "gsl-aux.h QRunpack" c_qrUnpack :: TMVMM+++type TMMV = Int -> Int -> PD -> TMV+type TMVMM = Int -> Int -> PD -> Int -> PD -> TMM++{- | Cholesky decomposition of a symmetric positive definite real matrix using /gsl_linalg_cholesky_decomp/.++@\> chol $ (2><2) [1,2,+                   2,9::Double]+(2><2)+ [ 1.0,              0.0+ , 2.0, 2.23606797749979 ]@++-}+cholR :: Matrix Double -> Matrix Double+cholR = cholR' . cmat++cholR' x = unsafePerformIO $ do+    r <- createMatrix RowMajor n n+    app2 c_cholR mat x mat r "cholR"+    return r+  where n = rows x+foreign import ccall "gsl-aux.h cholR" c_cholR :: TMM++cholC :: Matrix (Complex Double) -> Matrix (Complex Double)+cholC = cholC' . cmat++cholC' x = unsafePerformIO $ do+    r <- createMatrix RowMajor n n+    app2 c_cholC mat x mat r "cholC"+    return r+  where n = rows x+foreign import ccall "gsl-aux.h cholC" c_cholC :: TCMCM+++--------------------------------------------------------++{- -| efficient multiplication by the inverse of a matrix (for real matrices)+-}+luSolveR :: Matrix Double -> Matrix Double -> Matrix Double+luSolveR a b = luSolveR' (cmat a) (cmat b)++luSolveR' a b+    | n1==n2 && n1==r = unsafePerformIO $ do+        s <- createMatrix RowMajor r c+        app3 c_luSolveR mat a mat b mat s "luSolveR"+        return s+    | otherwise = error "luSolveR of nonsquare matrix"+  where n1 = rows a+        n2 = cols a+        r  = rows b+        c  = cols b+foreign import ccall "gsl-aux.h luSolveR" c_luSolveR ::  TMMM++{- -| efficient multiplication by the inverse of a matrix (for complex matrices). +-}+luSolveC :: Matrix (Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)+luSolveC a b = luSolveC' (cmat a) (cmat b)++luSolveC' a b+    | n1==n2 && n1==r = unsafePerformIO $ do+        s <- createMatrix RowMajor r c+        app3 c_luSolveC mat a mat b mat s "luSolveC"+        return s+    | otherwise = error "luSolveC of nonsquare matrix"+  where n1 = rows a+        n2 = cols a+        r  = rows b+        c  = cols b+foreign import ccall "gsl-aux.h luSolveC" c_luSolveC ::  TCMCMCM++{- | lu decomposition of real matrix (packed as a vector including l, u, the permutation and sign)+-}+luRaux  :: Matrix Double -> Vector Double+luRaux = luRaux' . cmat++luRaux' x = unsafePerformIO $ do+    res <- createVector (r*r+r+1)+    app2 c_luRaux mat x vec res "luRaux"+    return res+  where r = rows x+foreign import ccall "gsl-aux.h luRaux" c_luRaux :: TMV++{- | lu decomposition of complex matrix (packed as a vector including l, u, the permutation and sign)+-}+luCaux  :: Matrix (Complex Double) -> Vector (Complex Double)+luCaux = luCaux' . cmat++luCaux' x = unsafePerformIO $ do+    res <- createVector (r*r+r+1)+    app2 c_luCaux mat x vec res "luCaux"+    return res+  where r = rows x+foreign import ccall "gsl-aux.h luCaux" c_luCaux :: TCMCV++{- | The LU decomposition of a square matrix. Is based on /gsl_linalg_LU_decomp/ and  /gsl_linalg_complex_LU_decomp/ as described in <http://www.gnu.org/software/Numeric.GSL/manual/Numeric.GSL-ref_13.html#SEC223>.++@\> let m = 'fromLists' [[1,2,-3],[2+3*i,-7,0],[1,-i,2*i]]+\> let (l,u,p,s) = luR m@++L is the lower triangular:++@\> l+          1.            0.  0.+0.154-0.231i            1.  0.+0.154-0.231i  0.624-0.522i  1.@++U is the upper triangular:++@\> u+2.+3.i           -7.            0.+    0.  3.077-1.615i           -3.+    0.            0.  1.873+0.433i@++p is a permutation:++@\> p+[1,0,2]@++L \* U obtains a permuted version of the original matrix:++@\> extractRows p m+  2.+3.i   -7.   0.+      1.    2.  -3.+      1.  -1.i  2.i+\ +\> l \<\> u+ 2.+3.i   -7.   0.+     1.    2.  -3.+     1.  -1.i  2.i@++s is the sign of the permutation, required to obtain sign of the determinant:++@\> s * product ('toList' $ 'takeDiag' u)+(-18.0) :+ (-16.000000000000004)+\> 'LinearAlgebra.Algorithms.det' m+(-18.0) :+ (-16.000000000000004)@++ -}+luR :: Matrix Double -> (Matrix Double, Matrix Double, [Int], Double)+luR m = (l,u,p, fromIntegral s') where+    r = rows m+    v = luRaux m+    lu = reshape r $ subVector 0 (r*r) v+    s':p = map round . toList . subVector (r*r) (r+1) $ v+    u = triang r r 0 1`mul` lu+    l = (triang r r 0 0 `mul` lu) `add` ident r+    add = liftMatrix2 $ vectorZipR Add+    mul = liftMatrix2 $ vectorZipR Mul++-- | Complex version of 'luR'.+luC :: Matrix (Complex Double) -> (Matrix (Complex Double), Matrix (Complex Double), [Int], Complex Double)+luC m = (l,u,p, fromIntegral s') where+    r = rows m+    v = luCaux m+    lu = reshape r $ subVector 0 (r*r) v+    s':p = map (round.realPart) . toList . subVector (r*r) (r+1) $ v+    u = triang r r 0 1 `mul` lu+    l = (triang r r 0 0 `mul` lu) `add` liftMatrix comp (ident r)+    add = liftMatrix2 $ vectorZipC Add+    mul = liftMatrix2 $ vectorZipC Mul++{- auxiliary function to get triangular matrices+-}+triang r c h v = reshape c $ fromList [el i j | i<-[0..r-1], j<-[0..c-1]]+    where el i j = if j-i>=h then v else 1 - v
+ lib/Numeric/GSL/Minimization.hs view
@@ -0,0 +1,206 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Minimization+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Minimization of a multidimensional function Minimization of a multidimensional function using some of the algorithms described in:++<http://www.gnu.org/software/gsl/manual/html_node/Multidimensional-Minimization.html>++-}+-----------------------------------------------------------------------------+module Numeric.GSL.Minimization (+    minimizeConjugateGradient,+    minimizeNMSimplex+) where+++import Data.Packed.Internal+import Data.Packed.Matrix+import Foreign++-------------------------------------------------------------------------++{- | The method of Nelder and Mead, implemented by /gsl_multimin_fminimizer_nmsimplex/. The gradient of the function is not required. This is the example in the GSL manual:++@minimize f xi = minimizeNMSimplex f xi (replicate (length xi) 1) 1e-2 100+\ +f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30+\ +main = do+    let (s,p) = minimize f [5,7]+    print s+    print p+\ +\> main+[0.9920430849306285,1.9969168063253164]+0. 512.500    1.082 6.500    5.+ 1. 290.625    1.372 5.250    4.+ 2. 290.625    1.372 5.250    4.+ 3. 252.500    1.372 5.500    1.+ 4. 101.406    1.823 2.625 3.500+ 5. 101.406    1.823 2.625 3.500+ 6.     60.    1.823    0.    3.+ 7.  42.275    1.303 2.094 1.875+ 8.  42.275    1.303 2.094 1.875+ 9.  35.684    1.026 0.258 1.906+10.  35.664    0.804 0.588 2.445+11.  30.680    0.467 1.258 2.025+12.  30.680    0.356 1.258 2.025+13.  30.539    0.285 1.093 1.849+14.  30.137    0.168 0.883 2.004+15.  30.137    0.123 0.883 2.004+16.  30.090    0.100 0.958 2.060+17.  30.005 6.051e-2 1.022 2.004+18.  30.005 4.249e-2 1.022 2.004+19.  30.005 4.249e-2 1.022 2.004+20.  30.005 2.742e-2 1.022 2.004+21.  30.005 2.119e-2 1.022 2.004+22.  30.001 1.530e-2 0.992 1.997+23.  30.001 1.259e-2 0.992 1.997+24.  30.001 7.663e-3 0.992 1.997@++The path to the solution can be graphically shown by means of:++@'GSL.Plot.mplot' $ drop 3 ('toColumns' p)@++-}+minimizeNMSimplex :: ([Double] -> Double) -- ^ function to minimize+          -> [Double]            -- ^ starting point+          -> [Double]            -- ^ sizes of the initial search box+          -> Double              -- ^ desired precision of the solution+          -> Int                 -- ^ maximum number of iterations allowed+          -> ([Double], Matrix Double)+          -- ^ solution vector, and the optimization trajectory followed by the algorithm+minimizeNMSimplex f xi sz tol maxit = unsafePerformIO $ do+    let xiv = fromList xi+        szv = fromList sz+        n   = dim xiv+    fp <- mkVecfun (iv (f.toList))+    rawpath <- ww2 withVector xiv withVector szv $ \xiv' szv' ->+                   createMIO maxit (n+3)+                         (c_minimizeNMSimplex fp tol maxit // xiv' // szv')+                         "minimizeNMSimplex"+    let it = round (rawpath @@> (maxit-1,0))+        path = takeRows it rawpath+        [sol] = toLists $ dropRows (it-1) path+    freeHaskellFunPtr fp+    return (drop 3 sol, path)+++foreign import ccall "gsl-aux.h minimize"+    c_minimizeNMSimplex:: FunPtr (Int -> Ptr Double -> Double) -> Double -> Int+                       -> TVVM++----------------------------------------------------------------------------------++{- | The Fletcher-Reeves conjugate gradient algorithm /gsl_multimin_fminimizer_conjugate_fr/. This is the example in the GSL manual:++@minimize = minimizeConjugateGradient 1E-2 1E-4 1E-3 30+f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30+\ +df [x,y] = [20*(x-1), 40*(y-2)]+\  +main = do+    let (s,p) = minimize f df [5,7]+    print s+    print p+\ +\> main+[1.0,2.0]+ 0. 687.848 4.996 6.991+ 1. 683.555 4.989 6.972+ 2. 675.013 4.974 6.935+ 3. 658.108 4.944 6.861+ 4. 625.013 4.885 6.712+ 5. 561.684 4.766 6.415+ 6. 446.467 4.528 5.821+ 7. 261.794 4.053 4.632+ 8.  75.498 3.102 2.255+ 9.  67.037 2.852 1.630+10.  45.316 2.191 1.762+11.  30.186 0.869 2.026+12.     30.    1.    2.@++The path to the solution can be graphically shown by means of:++@'GSL.Plot.mplot' $ drop 2 ('toColumns' p)@++-}     +minimizeConjugateGradient ::+       Double        -- ^ initial step size+    -> Double        -- ^ minimization parameter   +    -> Double        -- ^ desired precision of the solution (gradient test)+    -> Int           -- ^ maximum number of iterations allowed+    -> ([Double] -> Double) -- ^ function to minimize+    -> ([Double] -> [Double])      -- ^ gradient+    -> [Double]             -- ^ starting point+    -> ([Double], Matrix Double)        -- ^ solution vector, and the optimization trajectory followed by the algorithm+minimizeConjugateGradient istep minimpar tol maxit f df xi = unsafePerformIO $ do+    let xiv = fromList xi+        n = dim xiv+        f' = f . toList+        df' = (fromList . df . toList)+    fp <- mkVecfun (iv f')+    dfp <- mkVecVecfun (aux_vTov df')+    rawpath <- withVector xiv $ \xiv' ->+                    createMIO maxit (n+2)+                         (c_minimizeConjugateGradient fp dfp istep minimpar tol maxit // xiv')+                         "minimizeDerivV"+    let it = round (rawpath @@> (maxit-1,0))+        path = takeRows it rawpath+        sol = toList $ cdat $ dropColumns 2 $ dropRows (it-1) path+    freeHaskellFunPtr fp+    freeHaskellFunPtr dfp+    return (sol,path)+++foreign import ccall "gsl-aux.h minimizeWithDeriv"+    c_minimizeConjugateGradient :: FunPtr (Int -> Ptr Double -> Double)+                                -> FunPtr (Int -> Ptr Double -> Ptr Double -> IO ())+                                -> Double -> Double -> Double -> Int+                                -> TVM++---------------------------------------------------------------------+iv :: (Vector Double -> Double) -> (Int -> Ptr Double -> Double)+iv f n p = f (createV n copy "iv") where+    copy n' q = do+        copyArray q p n'+        return 0++-- | conversion of Haskell functions into function pointers that can be used in the C side+foreign import ccall "wrapper"+    mkVecfun :: (Int -> Ptr Double -> Double)+             -> IO( FunPtr (Int -> Ptr Double -> Double))++-- | another required conversion+foreign import ccall "wrapper"+    mkVecVecfun :: (Int -> Ptr Double -> Ptr Double -> IO ())+                -> IO (FunPtr (Int -> Ptr Double -> Ptr Double->IO()))++aux_vTov :: (Vector Double -> Vector Double) -> (Int -> Ptr Double -> Ptr Double -> IO())+aux_vTov f n p r = g where+    V {fptr = pr} = f x+    x = createV n copy "aux_vTov"+    copy n' q = do+        copyArray q p n'+        return 0+    g = withForeignPtr pr $ \p' -> copyArray r p' n++--------------------------------------------------------------------++createV n fun msg = unsafePerformIO $ do+    r <- createVector n+    app1 fun vec r msg+    return r++createMIO r c fun msg = do+    res <- createMatrix RowMajor r c+    app1 fun mat res msg+    return res
+ lib/Numeric/GSL/Polynomials.hs view
@@ -0,0 +1,54 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Polynomials+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Polynomials.++<http://www.gnu.org/software/gsl/manual/html_node/General-Polynomial-Equations.html#General-Polynomial-Equations>++-}+-----------------------------------------------------------------------------+module Numeric.GSL.Polynomials (+    polySolve+) where++import Data.Packed.Internal+import Complex+import Foreign++{- | Solution of general polynomial equations, using /gsl_poly_complex_solve/. For example,+     the three solutions of x^3 + 8 = 0++@\> polySolve [8,0,0,1]+[(-1.9999999999999998) :+ 0.0,+ 1.0 :+ 1.732050807568877,+ 1.0 :+ (-1.732050807568877)]@++The example in the GSL manual: To find the roots of x^5 -1 = 0:++@\> polySolve [-1, 0, 0, 0, 0, 1]+[(-0.8090169943749475) :+ 0.5877852522924731,+(-0.8090169943749475) :+ (-0.5877852522924731),+0.30901699437494734 :+ 0.9510565162951536,+0.30901699437494734 :+ (-0.9510565162951536),+1.0 :+ 0.0]@++-}  +polySolve :: [Double] -> [Complex Double]+polySolve = toList . polySolve' . fromList++polySolve' :: Vector Double -> Vector (Complex Double)+polySolve' v | dim v > 1 = unsafePerformIO $ do+    r <- createVector (dim v-1)+    app2 c_polySolve vec v vec r "polySolve"+    return r+             | otherwise = error "polySolve on a polynomial of degree zero"++foreign import ccall "gsl-aux.h polySolve" c_polySolve:: TVCV
+ lib/Numeric/GSL/Special.hs view
@@ -0,0 +1,72 @@+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected special functions.++<http://www.gnu.org/software/gsl/manual/html_node/Special-Functions.html#Special-Functions>+-}+-----------------------------------------------------------------------------++module Numeric.GSL.Special (+  module Numeric.GSL.Special.Airy+, module Numeric.GSL.Special.Bessel+, module Numeric.GSL.Special.Clausen+, module Numeric.GSL.Special.Coulomb+, module Numeric.GSL.Special.Coupling+, module Numeric.GSL.Special.Dawson+, module Numeric.GSL.Special.Debye+, module Numeric.GSL.Special.Dilog+, module Numeric.GSL.Special.Elementary+, module Numeric.GSL.Special.Ellint+, module Numeric.GSL.Special.Erf+, module Numeric.GSL.Special.Exp+, module Numeric.GSL.Special.Expint+, module Numeric.GSL.Special.Fermi_dirac+, module Numeric.GSL.Special.Gamma+, module Numeric.GSL.Special.Gegenbauer+, module Numeric.GSL.Special.Hyperg+, module Numeric.GSL.Special.Laguerre+, module Numeric.GSL.Special.Lambert+, module Numeric.GSL.Special.Legendre+, module Numeric.GSL.Special.Log+, module Numeric.GSL.Special.Pow_int+, module Numeric.GSL.Special.Psi+, module Numeric.GSL.Special.Synchrotron+, module Numeric.GSL.Special.Trig+, module Numeric.GSL.Special.Zeta+)+where++import Numeric.GSL.Special.Airy+import Numeric.GSL.Special.Bessel+import Numeric.GSL.Special.Clausen+import Numeric.GSL.Special.Coulomb+import Numeric.GSL.Special.Coupling+import Numeric.GSL.Special.Dawson+import Numeric.GSL.Special.Debye+import Numeric.GSL.Special.Dilog+import Numeric.GSL.Special.Elementary+import Numeric.GSL.Special.Ellint+import Numeric.GSL.Special.Erf+import Numeric.GSL.Special.Exp+import Numeric.GSL.Special.Expint+import Numeric.GSL.Special.Fermi_dirac+import Numeric.GSL.Special.Gamma+import Numeric.GSL.Special.Gegenbauer+import Numeric.GSL.Special.Hyperg+import Numeric.GSL.Special.Laguerre+import Numeric.GSL.Special.Lambert+import Numeric.GSL.Special.Legendre+import Numeric.GSL.Special.Log+import Numeric.GSL.Special.Pow_int+import Numeric.GSL.Special.Psi+import Numeric.GSL.Special.Synchrotron+import Numeric.GSL.Special.Trig+import Numeric.GSL.Special.Zeta
+ lib/Numeric/GSL/Special/Airy.hs view
@@ -0,0 +1,166 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Airy+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.gnu.org/software/gsl/manual/html_node/Airy-Functions-and-Derivatives.html>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Airy(+  Precision (..)+, airy_Ai_e+, airy_Ai+, airy_Bi_e+, airy_Bi+, airy_Ai_scaled_e+, airy_Ai_scaled+, airy_Bi_scaled_e+, airy_Bi_scaled+, airy_Ai_deriv_e+, airy_Ai_deriv+, airy_Bi_deriv_e+, airy_Bi_deriv+, airy_Ai_deriv_scaled_e+, airy_Ai_deriv_scaled+, airy_Bi_deriv_scaled_e+, airy_Bi_deriv_scaled+, airy_zero_Ai_e+, airy_zero_Ai+, airy_zero_Bi_e+, airy_zero_Bi+, airy_zero_Ai_deriv_e+, airy_zero_Ai_deriv+, airy_zero_Bi_deriv_e+, airy_zero_Bi_deriv+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_airy_Ai_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Ai_e :: Double -> Precision -> (Double,Double)+airy_Ai_e x mode = createSFR "airy_Ai_e" $ gsl_sf_airy_Ai_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Ai(double x,gsl_mode_t mode);+airy_Ai :: Double -> Precision -> Double+airy_Ai x mode = gsl_sf_airy_Ai x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_Bi_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Bi_e :: Double -> Precision -> (Double,Double)+airy_Bi_e x mode = createSFR "airy_Bi_e" $ gsl_sf_airy_Bi_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Bi(double x,gsl_mode_t mode);+airy_Bi :: Double -> Precision -> Double+airy_Bi x mode = gsl_sf_airy_Bi x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_Ai_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Ai_scaled_e :: Double -> Precision -> (Double,Double)+airy_Ai_scaled_e x mode = createSFR "airy_Ai_scaled_e" $ gsl_sf_airy_Ai_scaled_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Ai_scaled(double x,gsl_mode_t mode);+airy_Ai_scaled :: Double -> Precision -> Double+airy_Ai_scaled x mode = gsl_sf_airy_Ai_scaled x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_Bi_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Bi_scaled_e :: Double -> Precision -> (Double,Double)+airy_Bi_scaled_e x mode = createSFR "airy_Bi_scaled_e" $ gsl_sf_airy_Bi_scaled_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Bi_scaled(double x,gsl_mode_t mode);+airy_Bi_scaled :: Double -> Precision -> Double+airy_Bi_scaled x mode = gsl_sf_airy_Bi_scaled x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_Ai_deriv_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Ai_deriv_e :: Double -> Precision -> (Double,Double)+airy_Ai_deriv_e x mode = createSFR "airy_Ai_deriv_e" $ gsl_sf_airy_Ai_deriv_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Ai_deriv(double x,gsl_mode_t mode);+airy_Ai_deriv :: Double -> Precision -> Double+airy_Ai_deriv x mode = gsl_sf_airy_Ai_deriv x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_Bi_deriv_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Bi_deriv_e :: Double -> Precision -> (Double,Double)+airy_Bi_deriv_e x mode = createSFR "airy_Bi_deriv_e" $ gsl_sf_airy_Bi_deriv_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Bi_deriv(double x,gsl_mode_t mode);+airy_Bi_deriv :: Double -> Precision -> Double+airy_Bi_deriv x mode = gsl_sf_airy_Bi_deriv x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_Ai_deriv_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Ai_deriv_scaled_e :: Double -> Precision -> (Double,Double)+airy_Ai_deriv_scaled_e x mode = createSFR "airy_Ai_deriv_scaled_e" $ gsl_sf_airy_Ai_deriv_scaled_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Ai_deriv_scaled(double x,gsl_mode_t mode);+airy_Ai_deriv_scaled :: Double -> Precision -> Double+airy_Ai_deriv_scaled x mode = gsl_sf_airy_Ai_deriv_scaled x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_Bi_deriv_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);+airy_Bi_deriv_scaled_e :: Double -> Precision -> (Double,Double)+airy_Bi_deriv_scaled_e x mode = createSFR "airy_Bi_deriv_scaled_e" $ gsl_sf_airy_Bi_deriv_scaled_e x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_Bi_deriv_scaled(double x,gsl_mode_t mode);+airy_Bi_deriv_scaled :: Double -> Precision -> Double+airy_Bi_deriv_scaled x mode = gsl_sf_airy_Bi_deriv_scaled x  (precCode mode)+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_airy_zero_Ai_e(int s,gsl_sf_result* result);+airy_zero_Ai_e :: Int -> (Double,Double)+airy_zero_Ai_e s = createSFR "airy_zero_Ai_e" $ gsl_sf_airy_zero_Ai_e s+foreign import ccall "airy.h gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_zero_Ai(int s);+airy_zero_Ai :: Int -> Double+airy_zero_Ai = gsl_sf_airy_zero_Ai+foreign import ccall "airy.h gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: Int -> Double++-- | wrapper for int gsl_sf_airy_zero_Bi_e(int s,gsl_sf_result* result);+airy_zero_Bi_e :: Int -> (Double,Double)+airy_zero_Bi_e s = createSFR "airy_zero_Bi_e" $ gsl_sf_airy_zero_Bi_e s+foreign import ccall "airy.h gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_zero_Bi(int s);+airy_zero_Bi :: Int -> Double+airy_zero_Bi = gsl_sf_airy_zero_Bi+foreign import ccall "airy.h gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: Int -> Double++-- | wrapper for int gsl_sf_airy_zero_Ai_deriv_e(int s,gsl_sf_result* result);+airy_zero_Ai_deriv_e :: Int -> (Double,Double)+airy_zero_Ai_deriv_e s = createSFR "airy_zero_Ai_deriv_e" $ gsl_sf_airy_zero_Ai_deriv_e s+foreign import ccall "airy.h gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_zero_Ai_deriv(int s);+airy_zero_Ai_deriv :: Int -> Double+airy_zero_Ai_deriv = gsl_sf_airy_zero_Ai_deriv+foreign import ccall "airy.h gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: Int -> Double++-- | wrapper for int gsl_sf_airy_zero_Bi_deriv_e(int s,gsl_sf_result* result);+airy_zero_Bi_deriv_e :: Int -> (Double,Double)+airy_zero_Bi_deriv_e s = createSFR "airy_zero_Bi_deriv_e" $ gsl_sf_airy_zero_Bi_deriv_e s+foreign import ccall "airy.h gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_airy_zero_Bi_deriv(int s);+airy_zero_Bi_deriv :: Int -> Double+airy_zero_Bi_deriv = gsl_sf_airy_zero_Bi_deriv+foreign import ccall "airy.h gsl_sf_airy_zero_Bi_deriv" gsl_sf_airy_zero_Bi_deriv :: Int -> Double
+ lib/Numeric/GSL/Special/Bessel.hs view
@@ -0,0 +1,809 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Bessel+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_bessel.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Bessel(+  bessel_J0_e+, bessel_J0+, bessel_J1_e+, bessel_J1+, bessel_Jn_e+, bessel_Jn+, bessel_Y0_e+, bessel_Y0+, bessel_Y1_e+, bessel_Y1+, bessel_Yn_e+, bessel_Yn+, bessel_I0_e+, bessel_I0+, bessel_I1_e+, bessel_I1+, bessel_In_e+, bessel_In+, bessel_I0_scaled_e+, bessel_I0_scaled+, bessel_I1_scaled_e+, bessel_I1_scaled+, bessel_In_scaled_e+, bessel_In_scaled+, bessel_K0_e+, bessel_K0+, bessel_K1_e+, bessel_K1+, bessel_Kn_e+, bessel_Kn+, bessel_K0_scaled_e+, bessel_K0_scaled+, bessel_K1_scaled_e+, bessel_K1_scaled+, bessel_Kn_scaled_e+, bessel_Kn_scaled+, bessel_j0_e+, bessel_j0+, bessel_j1_e+, bessel_j1+, bessel_j2_e+, bessel_j2+, bessel_jl_e+, bessel_jl+, bessel_y0_e+, bessel_y0+, bessel_y1_e+, bessel_y1+, bessel_y2_e+, bessel_y2+, bessel_yl_e+, bessel_yl+, bessel_i0_scaled_e+, bessel_i0_scaled+, bessel_i1_scaled_e+, bessel_i1_scaled+, bessel_i2_scaled_e+, bessel_i2_scaled+, bessel_il_scaled_e+, bessel_il_scaled+, bessel_k0_scaled_e+, bessel_k0_scaled+, bessel_k1_scaled_e+, bessel_k1_scaled+, bessel_k2_scaled_e+, bessel_k2_scaled+, bessel_kl_scaled_e+, bessel_kl_scaled+, bessel_Jnu_e+, bessel_Jnu+, bessel_Ynu_e+, bessel_Ynu+, bessel_Inu_scaled_e+, bessel_Inu_scaled+, bessel_Inu_e+, bessel_Inu+, bessel_Knu_scaled_e+, bessel_Knu_scaled+, bessel_Knu_e+, bessel_Knu+, bessel_lnKnu_e+, bessel_lnKnu+, bessel_zero_J0_e+, bessel_zero_J0+, bessel_zero_J1_e+, bessel_zero_J1+, bessel_zero_Jnu_e+, bessel_zero_Jnu+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_bessel_J0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_J0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_J0_e :: Double -> (Double,Double)+bessel_J0_e x = createSFR "bessel_J0_e" $ gsl_sf_bessel_J0_e x+foreign import ccall "bessel.h gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_J0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_J0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_J0 :: Double -> Double+bessel_J0 = gsl_sf_bessel_J0+foreign import ccall "bessel.h gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_J1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_J1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_J1_e :: Double -> (Double,Double)+bessel_J1_e x = createSFR "bessel_J1_e" $ gsl_sf_bessel_J1_e x+foreign import ccall "bessel.h gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_J1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_J1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_J1 :: Double -> Double+bessel_J1 = gsl_sf_bessel_J1+foreign import ccall "bessel.h gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_Jn_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Jn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Jn_e :: Int -> Double -> (Double,Double)+bessel_Jn_e n x = createSFR "bessel_Jn_e" $ gsl_sf_bessel_Jn_e n x+foreign import ccall "bessel.h gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Jn(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Jn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Jn :: Int -> Double -> Double+bessel_Jn = gsl_sf_bessel_Jn+foreign import ccall "bessel.h gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Jn_array(int nmin,int nmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Jn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Jn_array :: Int -> Int -> Double -> Ptr Double -> Int+bessel_Jn_array = gsl_sf_bessel_Jn_array+foreign import ccall "bessel.h gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_Y0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Y0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Y0_e :: Double -> (Double,Double)+bessel_Y0_e x = createSFR "bessel_Y0_e" $ gsl_sf_bessel_Y0_e x+foreign import ccall "bessel.h gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Y0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Y0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Y0 :: Double -> Double+bessel_Y0 = gsl_sf_bessel_Y0+foreign import ccall "bessel.h gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_Y1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Y1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Y1_e :: Double -> (Double,Double)+bessel_Y1_e x = createSFR "bessel_Y1_e" $ gsl_sf_bessel_Y1_e x+foreign import ccall "bessel.h gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Y1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Y1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Y1 :: Double -> Double+bessel_Y1 = gsl_sf_bessel_Y1+foreign import ccall "bessel.h gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_Yn_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Yn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Yn_e :: Int -> Double -> (Double,Double)+bessel_Yn_e n x = createSFR "bessel_Yn_e" $ gsl_sf_bessel_Yn_e n x+foreign import ccall "bessel.h gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Yn(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Yn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Yn :: Int -> Double -> Double+bessel_Yn = gsl_sf_bessel_Yn+foreign import ccall "bessel.h gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Yn_array(int nmin,int nmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Yn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Yn_array :: Int -> Int -> Double -> Ptr Double -> Int+bessel_Yn_array = gsl_sf_bessel_Yn_array+foreign import ccall "bessel.h gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_I0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I0_e :: Double -> (Double,Double)+bessel_I0_e x = createSFR "bessel_I0_e" $ gsl_sf_bessel_I0_e x+foreign import ccall "bessel.h gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_I0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I0 :: Double -> Double+bessel_I0 = gsl_sf_bessel_I0+foreign import ccall "bessel.h gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_I1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I1_e :: Double -> (Double,Double)+bessel_I1_e x = createSFR "bessel_I1_e" $ gsl_sf_bessel_I1_e x+foreign import ccall "bessel.h gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_I1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I1 :: Double -> Double+bessel_I1 = gsl_sf_bessel_I1+foreign import ccall "bessel.h gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_In_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_In_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_In_e :: Int -> Double -> (Double,Double)+bessel_In_e n x = createSFR "bessel_In_e" $ gsl_sf_bessel_In_e n x+foreign import ccall "bessel.h gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_In(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_In&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_In :: Int -> Double -> Double+bessel_In = gsl_sf_bessel_In+foreign import ccall "bessel.h gsl_sf_bessel_In" gsl_sf_bessel_In :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_In_array(int nmin,int nmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_In_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_In_array :: Int -> Int -> Double -> Ptr Double -> Int+bessel_In_array = gsl_sf_bessel_In_array+foreign import ccall "bessel.h gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_I0_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I0_scaled_e :: Double -> (Double,Double)+bessel_I0_scaled_e x = createSFR "bessel_I0_scaled_e" $ gsl_sf_bessel_I0_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_I0_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I0_scaled :: Double -> Double+bessel_I0_scaled = gsl_sf_bessel_I0_scaled+foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_I1_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I1_scaled_e :: Double -> (Double,Double)+bessel_I1_scaled_e x = createSFR "bessel_I1_scaled_e" $ gsl_sf_bessel_I1_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_I1_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_I1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_I1_scaled :: Double -> Double+bessel_I1_scaled = gsl_sf_bessel_I1_scaled+foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_In_scaled_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_In_scaled_e :: Int -> Double -> (Double,Double)+bessel_In_scaled_e n x = createSFR "bessel_In_scaled_e" $ gsl_sf_bessel_In_scaled_e n x+foreign import ccall "bessel.h gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_In_scaled(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_In_scaled :: Int -> Double -> Double+bessel_In_scaled = gsl_sf_bessel_In_scaled+foreign import ccall "bessel.h gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_In_scaled_array(int nmin,int nmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_In_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int+bessel_In_scaled_array = gsl_sf_bessel_In_scaled_array+foreign import ccall "bessel.h gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_K0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K0_e :: Double -> (Double,Double)+bessel_K0_e x = createSFR "bessel_K0_e" $ gsl_sf_bessel_K0_e x+foreign import ccall "bessel.h gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_K0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K0 :: Double -> Double+bessel_K0 = gsl_sf_bessel_K0+foreign import ccall "bessel.h gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_K1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K1_e :: Double -> (Double,Double)+bessel_K1_e x = createSFR "bessel_K1_e" $ gsl_sf_bessel_K1_e x+foreign import ccall "bessel.h gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_K1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K1 :: Double -> Double+bessel_K1 = gsl_sf_bessel_K1+foreign import ccall "bessel.h gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_Kn_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Kn_e :: Int -> Double -> (Double,Double)+bessel_Kn_e n x = createSFR "bessel_Kn_e" $ gsl_sf_bessel_Kn_e n x+foreign import ccall "bessel.h gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Kn(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Kn :: Int -> Double -> Double+bessel_Kn = gsl_sf_bessel_Kn+foreign import ccall "bessel.h gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Kn_array(int nmin,int nmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Kn_array :: Int -> Int -> Double -> Ptr Double -> Int+bessel_Kn_array = gsl_sf_bessel_Kn_array+foreign import ccall "bessel.h gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_K0_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K0_scaled_e :: Double -> (Double,Double)+bessel_K0_scaled_e x = createSFR "bessel_K0_scaled_e" $ gsl_sf_bessel_K0_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_K0_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K0_scaled :: Double -> Double+bessel_K0_scaled = gsl_sf_bessel_K0_scaled+foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_K1_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K1_scaled_e :: Double -> (Double,Double)+bessel_K1_scaled_e x = createSFR "bessel_K1_scaled_e" $ gsl_sf_bessel_K1_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_K1_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_K1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_K1_scaled :: Double -> Double+bessel_K1_scaled = gsl_sf_bessel_K1_scaled+foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_Kn_scaled_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Kn_scaled_e :: Int -> Double -> (Double,Double)+bessel_Kn_scaled_e n x = createSFR "bessel_Kn_scaled_e" $ gsl_sf_bessel_Kn_scaled_e n x+foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Kn_scaled(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Kn_scaled :: Int -> Double -> Double+bessel_Kn_scaled = gsl_sf_bessel_Kn_scaled+foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Kn_scaled_array(int nmin,int nmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Kn_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int+bessel_Kn_scaled_array = gsl_sf_bessel_Kn_scaled_array+foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_j0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_j0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_j0_e :: Double -> (Double,Double)+bessel_j0_e x = createSFR "bessel_j0_e" $ gsl_sf_bessel_j0_e x+foreign import ccall "bessel.h gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_j0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_j0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_j0 :: Double -> Double+bessel_j0 = gsl_sf_bessel_j0+foreign import ccall "bessel.h gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_j1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_j1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_j1_e :: Double -> (Double,Double)+bessel_j1_e x = createSFR "bessel_j1_e" $ gsl_sf_bessel_j1_e x+foreign import ccall "bessel.h gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_j1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_j1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_j1 :: Double -> Double+bessel_j1 = gsl_sf_bessel_j1+foreign import ccall "bessel.h gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_j2_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_j2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_j2_e :: Double -> (Double,Double)+bessel_j2_e x = createSFR "bessel_j2_e" $ gsl_sf_bessel_j2_e x+foreign import ccall "bessel.h gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_j2(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_j2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_j2 :: Double -> Double+bessel_j2 = gsl_sf_bessel_j2+foreign import ccall "bessel.h gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_jl_e(int l,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_jl_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_jl_e :: Int -> Double -> (Double,Double)+bessel_jl_e l x = createSFR "bessel_jl_e" $ gsl_sf_bessel_jl_e l x+foreign import ccall "bessel.h gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_jl(int l,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_jl&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_jl :: Int -> Double -> Double+bessel_jl = gsl_sf_bessel_jl+foreign import ccall "bessel.h gsl_sf_bessel_jl" gsl_sf_bessel_jl :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_jl_array(int lmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_jl_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_jl_array :: Int -> Double -> Ptr Double -> Int+bessel_jl_array = gsl_sf_bessel_jl_array+foreign import ccall "bessel.h gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_jl_steed_array(int lmax,double x,double* jl_x_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_jl_steed_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_jl_steed_array :: Int -> Double -> Ptr Double -> Int+bessel_jl_steed_array = gsl_sf_bessel_jl_steed_array+foreign import ccall "bessel.h gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_y0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_y0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_y0_e :: Double -> (Double,Double)+bessel_y0_e x = createSFR "bessel_y0_e" $ gsl_sf_bessel_y0_e x+foreign import ccall "bessel.h gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_y0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_y0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_y0 :: Double -> Double+bessel_y0 = gsl_sf_bessel_y0+foreign import ccall "bessel.h gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_y1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_y1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_y1_e :: Double -> (Double,Double)+bessel_y1_e x = createSFR "bessel_y1_e" $ gsl_sf_bessel_y1_e x+foreign import ccall "bessel.h gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_y1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_y1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_y1 :: Double -> Double+bessel_y1 = gsl_sf_bessel_y1+foreign import ccall "bessel.h gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_y2_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_y2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_y2_e :: Double -> (Double,Double)+bessel_y2_e x = createSFR "bessel_y2_e" $ gsl_sf_bessel_y2_e x+foreign import ccall "bessel.h gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_y2(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_y2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_y2 :: Double -> Double+bessel_y2 = gsl_sf_bessel_y2+foreign import ccall "bessel.h gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double++-- | wrapper for int gsl_sf_bessel_yl_e(int l,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_yl_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_yl_e :: Int -> Double -> (Double,Double)+bessel_yl_e l x = createSFR "bessel_yl_e" $ gsl_sf_bessel_yl_e l x+foreign import ccall "bessel.h gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_yl(int l,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_yl&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_yl :: Int -> Double -> Double+bessel_yl = gsl_sf_bessel_yl+foreign import ccall "bessel.h gsl_sf_bessel_yl" gsl_sf_bessel_yl :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_yl_array(int lmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_yl_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_yl_array :: Int -> Double -> Ptr Double -> Int+bessel_yl_array = gsl_sf_bessel_yl_array+foreign import ccall "bessel.h gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_i0_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_i0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_i0_scaled_e :: Double -> (Double,Double)+bessel_i0_scaled_e x = createSFR "bessel_i0_scaled_e" $ gsl_sf_bessel_i0_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_i0_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_i0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_i0_scaled :: Double -> Double+bessel_i0_scaled = gsl_sf_bessel_i0_scaled+foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_i1_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_i1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_i1_scaled_e :: Double -> (Double,Double)+bessel_i1_scaled_e x = createSFR "bessel_i1_scaled_e" $ gsl_sf_bessel_i1_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_i1_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_i1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_i1_scaled :: Double -> Double+bessel_i1_scaled = gsl_sf_bessel_i1_scaled+foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_i2_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_i2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_i2_scaled_e :: Double -> (Double,Double)+bessel_i2_scaled_e x = createSFR "bessel_i2_scaled_e" $ gsl_sf_bessel_i2_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_i2_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_i2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_i2_scaled :: Double -> Double+bessel_i2_scaled = gsl_sf_bessel_i2_scaled+foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_il_scaled_e(int l,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_il_scaled_e :: Int -> Double -> (Double,Double)+bessel_il_scaled_e l x = createSFR "bessel_il_scaled_e" $ gsl_sf_bessel_il_scaled_e l x+foreign import ccall "bessel.h gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_il_scaled(int l,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_il_scaled :: Int -> Double -> Double+bessel_il_scaled = gsl_sf_bessel_il_scaled+foreign import ccall "bessel.h gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_il_scaled_array(int lmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_il_scaled_array :: Int -> Double -> Ptr Double -> Int+bessel_il_scaled_array = gsl_sf_bessel_il_scaled_array+foreign import ccall "bessel.h gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_k0_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_k0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_k0_scaled_e :: Double -> (Double,Double)+bessel_k0_scaled_e x = createSFR "bessel_k0_scaled_e" $ gsl_sf_bessel_k0_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_k0_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_k0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_k0_scaled :: Double -> Double+bessel_k0_scaled = gsl_sf_bessel_k0_scaled+foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_k1_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_k1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_k1_scaled_e :: Double -> (Double,Double)+bessel_k1_scaled_e x = createSFR "bessel_k1_scaled_e" $ gsl_sf_bessel_k1_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_k1_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_k1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_k1_scaled :: Double -> Double+bessel_k1_scaled = gsl_sf_bessel_k1_scaled+foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_k2_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_k2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_k2_scaled_e :: Double -> (Double,Double)+bessel_k2_scaled_e x = createSFR "bessel_k2_scaled_e" $ gsl_sf_bessel_k2_scaled_e x+foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_k2_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_k2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_k2_scaled :: Double -> Double+bessel_k2_scaled = gsl_sf_bessel_k2_scaled+foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double++-- | wrapper for int gsl_sf_bessel_kl_scaled_e(int l,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_kl_scaled_e :: Int -> Double -> (Double,Double)+bessel_kl_scaled_e l x = createSFR "bessel_kl_scaled_e" $ gsl_sf_bessel_kl_scaled_e l x+foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_kl_scaled(int l,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_kl_scaled :: Int -> Double -> Double+bessel_kl_scaled = gsl_sf_bessel_kl_scaled+foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: Int -> Double -> Double++-- | wrapper for int gsl_sf_bessel_kl_scaled_array(int lmax,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_kl_scaled_array :: Int -> Double -> Ptr Double -> Int+bessel_kl_scaled_array = gsl_sf_bessel_kl_scaled_array+foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_Jnu_e(double nu,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Jnu_e :: Double -> Double -> (Double,Double)+bessel_Jnu_e nu x = createSFR "bessel_Jnu_e" $ gsl_sf_bessel_Jnu_e nu x+foreign import ccall "bessel.h gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Jnu(double nu,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Jnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Jnu :: Double -> Double -> Double+bessel_Jnu = gsl_sf_bessel_Jnu+foreign import ccall "bessel.h gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Ynu_e(double nu,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Ynu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Ynu_e :: Double -> Double -> (Double,Double)+bessel_Ynu_e nu x = createSFR "bessel_Ynu_e" $ gsl_sf_bessel_Ynu_e nu x+foreign import ccall "bessel.h gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Ynu(double nu,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Ynu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Ynu :: Double -> Double -> Double+bessel_Ynu = gsl_sf_bessel_Ynu+foreign import ccall "bessel.h gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double++-- | wrapper for int gsl_sf_bessel_sequence_Jnu_e(double nu,gsl_mode_t mode,size_t size,double* v);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_sequence_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_sequence_Jnu_e :: Double -> Precision -> Size_t -> Ptr Double -> Int+bessel_sequence_Jnu_e nu mode size v = gsl_sf_bessel_sequence_Jnu_e nu  (precCode mode) size v+foreign import ccall "bessel.h gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> Int++-- | wrapper for int gsl_sf_bessel_Inu_scaled_e(double nu,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Inu_scaled_e :: Double -> Double -> (Double,Double)+bessel_Inu_scaled_e nu x = createSFR "bessel_Inu_scaled_e" $ gsl_sf_bessel_Inu_scaled_e nu x+foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Inu_scaled(double nu,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Inu_scaled :: Double -> Double -> Double+bessel_Inu_scaled = gsl_sf_bessel_Inu_scaled+foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Inu_e(double nu,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Inu_e :: Double -> Double -> (Double,Double)+bessel_Inu_e nu x = createSFR "bessel_Inu_e" $ gsl_sf_bessel_Inu_e nu x+foreign import ccall "bessel.h gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Inu(double nu,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Inu :: Double -> Double -> Double+bessel_Inu = gsl_sf_bessel_Inu+foreign import ccall "bessel.h gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Knu_scaled_e(double nu,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Knu_scaled_e :: Double -> Double -> (Double,Double)+bessel_Knu_scaled_e nu x = createSFR "bessel_Knu_scaled_e" $ gsl_sf_bessel_Knu_scaled_e nu x+foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Knu_scaled(double nu,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Knu_scaled :: Double -> Double -> Double+bessel_Knu_scaled = gsl_sf_bessel_Knu_scaled+foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double++-- | wrapper for int gsl_sf_bessel_Knu_e(double nu,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Knu_e :: Double -> Double -> (Double,Double)+bessel_Knu_e nu x = createSFR "bessel_Knu_e" $ gsl_sf_bessel_Knu_e nu x+foreign import ccall "bessel.h gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_Knu(double nu,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_Knu :: Double -> Double -> Double+bessel_Knu = gsl_sf_bessel_Knu+foreign import ccall "bessel.h gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double++-- | wrapper for int gsl_sf_bessel_lnKnu_e(double nu,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_lnKnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_lnKnu_e :: Double -> Double -> (Double,Double)+bessel_lnKnu_e nu x = createSFR "bessel_lnKnu_e" $ gsl_sf_bessel_lnKnu_e nu x+foreign import ccall "bessel.h gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_lnKnu(double nu,double x);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_lnKnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_lnKnu :: Double -> Double -> Double+bessel_lnKnu = gsl_sf_bessel_lnKnu+foreign import ccall "bessel.h gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double++-- | wrapper for int gsl_sf_bessel_zero_J0_e(int s,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_zero_J0_e :: Int -> (Double,Double)+bessel_zero_J0_e s = createSFR "bessel_zero_J0_e" $ gsl_sf_bessel_zero_J0_e s+foreign import ccall "bessel.h gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_zero_J0(int s);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_zero_J0 :: Int -> Double+bessel_zero_J0 = gsl_sf_bessel_zero_J0+foreign import ccall "bessel.h gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: Int -> Double++-- | wrapper for int gsl_sf_bessel_zero_J1_e(int s,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_zero_J1_e :: Int -> (Double,Double)+bessel_zero_J1_e s = createSFR "bessel_zero_J1_e" $ gsl_sf_bessel_zero_J1_e s+foreign import ccall "bessel.h gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_zero_J1(int s);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_zero_J1 :: Int -> Double+bessel_zero_J1 = gsl_sf_bessel_zero_J1+foreign import ccall "bessel.h gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: Int -> Double++-- | wrapper for int gsl_sf_bessel_zero_Jnu_e(double nu,int s,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_zero_Jnu_e :: Double -> Int -> (Double,Double)+bessel_zero_Jnu_e nu s = createSFR "bessel_zero_Jnu_e" $ gsl_sf_bessel_zero_Jnu_e nu s+foreign import ccall "bessel.h gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_bessel_zero_Jnu(double nu,int s);+--+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_Jnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+bessel_zero_Jnu :: Double -> Int -> Double+bessel_zero_Jnu = gsl_sf_bessel_zero_Jnu+foreign import ccall "bessel.h gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> Int -> Double
+ lib/Numeric/GSL/Special/Clausen.hs view
@@ -0,0 +1,37 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Clausen+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_clausen.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Clausen(+  clausen_e+, clausen+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_clausen_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_clausen_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+clausen_e :: Double -> (Double,Double)+clausen_e x = createSFR "clausen_e" $ gsl_sf_clausen_e x+foreign import ccall "clausen.h gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_clausen(double x);+--+--   <http://www.google.com/search?q=gsl_sf_clausen&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+clausen :: Double -> Double+clausen = gsl_sf_clausen+foreign import ccall "clausen.h gsl_sf_clausen" gsl_sf_clausen :: Double -> Double
+ lib/Numeric/GSL/Special/Coulomb.hs view
@@ -0,0 +1,103 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Coulomb+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_coulomb.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Coulomb(+  hydrogenicR_1_e+, hydrogenicR_1+, hydrogenicR_e+, hydrogenicR+, coulomb_CL_e+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_hydrogenicR_1_e(double Z,double r,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hydrogenicR_1_e :: Double -> Double -> (Double,Double)+hydrogenicR_1_e zZ r = createSFR "hydrogenicR_1_e" $ gsl_sf_hydrogenicR_1_e zZ r+foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hydrogenicR_1(double Z,double r);+--+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hydrogenicR_1 :: Double -> Double -> Double+hydrogenicR_1 = gsl_sf_hydrogenicR_1+foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_hydrogenicR_e(int n,int l,double Z,double r,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hydrogenicR_e :: Int -> Int -> Double -> Double -> (Double,Double)+hydrogenicR_e n l zZ r = createSFR "hydrogenicR_e" $ gsl_sf_hydrogenicR_e n l zZ r+foreign import ccall "coulomb.h gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: Int -> Int -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hydrogenicR(int n,int l,double Z,double r);+--+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hydrogenicR :: Int -> Int -> Double -> Double -> Double+hydrogenicR = gsl_sf_hydrogenicR+foreign import ccall "coulomb.h gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: Int -> Int -> Double -> Double -> Double++-- | wrapper for int gsl_sf_coulomb_wave_FG_e(double eta,double x,double lam_F,int k_lam_G,gsl_sf_result* F,gsl_sf_result* Fp,gsl_sf_result* G,gsl_sf_result* Gp,double* exp_F,double* exp_G);+--+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FG_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+coulomb_wave_FG_e :: Double -> Double -> Double -> Int -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int+coulomb_wave_FG_e = gsl_sf_coulomb_wave_FG_e+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> Int -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_coulomb_wave_F_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);+--+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_F_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+coulomb_wave_F_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int+coulomb_wave_F_array = gsl_sf_coulomb_wave_F_array+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_coulomb_wave_FG_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* gc_array,double* F_exponent,double* G_exponent);+--+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FG_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+coulomb_wave_FG_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int+coulomb_wave_FG_array = gsl_sf_coulomb_wave_FG_array+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FG_array" gsl_sf_coulomb_wave_FG_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_coulomb_wave_FGp_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* fcp_array,double* gc_array,double* gcp_array,double* F_exponent,double* G_exponent);+--+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FGp_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+coulomb_wave_FGp_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int+coulomb_wave_FGp_array = gsl_sf_coulomb_wave_FGp_array+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FGp_array" gsl_sf_coulomb_wave_FGp_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_coulomb_wave_sphF_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);+--+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_sphF_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+coulomb_wave_sphF_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int+coulomb_wave_sphF_array = gsl_sf_coulomb_wave_sphF_array+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_coulomb_CL_e(double L,double eta,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_coulomb_CL_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+coulomb_CL_e :: Double -> Double -> (Double,Double)+coulomb_CL_e lL eta = createSFR "coulomb_CL_e" $ gsl_sf_coulomb_CL_e lL eta+foreign import ccall "coulomb.h gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_coulomb_CL_array(double Lmin,int kmax,double eta,double* cl);+--+--   <http://www.google.com/search?q=gsl_sf_coulomb_CL_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+coulomb_CL_array :: Double -> Int -> Double -> Ptr Double -> Int+coulomb_CL_array = gsl_sf_coulomb_CL_array+foreign import ccall "coulomb.h gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> Int -> Double -> Ptr Double -> Int
+ lib/Numeric/GSL/Special/Coupling.hs view
@@ -0,0 +1,81 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Coupling+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.gnu.org/software/gsl/manual/html_node/Coupling-Coefficients.html>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Coupling(+  coupling_3j_e+, coupling_3j+, coupling_6j_e+, coupling_6j+, coupling_RacahW_e+, coupling_RacahW+, coupling_9j_e+, coupling_9j+-- , coupling_6j_INCORRECT_e+-- , coupling_6j_INCORRECT+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_coupling_3j_e(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc,gsl_sf_result* result);+coupling_3j_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)+coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc = createSFR "coupling_3j_e" $ gsl_sf_coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc+foreign import ccall "coupling.h gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_coupling_3j(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc);+coupling_3j :: Int -> Int -> Int -> Int -> Int -> Int -> Double+coupling_3j = gsl_sf_coupling_3j+foreign import ccall "coupling.h gsl_sf_coupling_3j" gsl_sf_coupling_3j :: Int -> Int -> Int -> Int -> Int -> Int -> Double++-- | wrapper for int gsl_sf_coupling_6j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);+coupling_6j_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)+coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_e" $ gsl_sf_coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf+foreign import ccall "coupling.h gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_coupling_6j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);+coupling_6j :: Int -> Int -> Int -> Int -> Int -> Int -> Double+coupling_6j = gsl_sf_coupling_6j+foreign import ccall "coupling.h gsl_sf_coupling_6j" gsl_sf_coupling_6j :: Int -> Int -> Int -> Int -> Int -> Int -> Double++-- | wrapper for int gsl_sf_coupling_RacahW_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);+coupling_RacahW_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)+coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_RacahW_e" $ gsl_sf_coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf+foreign import ccall "coupling.h gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_coupling_RacahW(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);+coupling_RacahW :: Int -> Int -> Int -> Int -> Int -> Int -> Double+coupling_RacahW = gsl_sf_coupling_RacahW+foreign import ccall "coupling.h gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: Int -> Int -> Int -> Int -> Int -> Int -> Double++-- | wrapper for int gsl_sf_coupling_9j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji,gsl_sf_result* result);+coupling_9j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)+coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji = createSFR "coupling_9j_e" $ gsl_sf_coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji+foreign import ccall "coupling.h gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_coupling_9j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji);+coupling_9j :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Double+coupling_9j = gsl_sf_coupling_9j+foreign import ccall "coupling.h gsl_sf_coupling_9j" gsl_sf_coupling_9j :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Double++-- | wrapper for int gsl_sf_coupling_6j_INCORRECT_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);+coupling_6j_INCORRECT_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)+coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_INCORRECT_e" $ gsl_sf_coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf+foreign import ccall "coupling.h gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_coupling_6j_INCORRECT(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);+coupling_6j_INCORRECT :: Int -> Int -> Int -> Int -> Int -> Int -> Double+coupling_6j_INCORRECT = gsl_sf_coupling_6j_INCORRECT+foreign import ccall "coupling.h gsl_sf_coupling_6j_INCORRECT" gsl_sf_coupling_6j_INCORRECT :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+ lib/Numeric/GSL/Special/Dawson.hs view
@@ -0,0 +1,37 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Dawson+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_dawson.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Dawson(+  dawson_e+, dawson+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_dawson_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_dawson_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+dawson_e :: Double -> (Double,Double)+dawson_e x = createSFR "dawson_e" $ gsl_sf_dawson_e x+foreign import ccall "dawson.h gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_dawson(double x);+--+--   <http://www.google.com/search?q=gsl_sf_dawson&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+dawson :: Double -> Double+dawson = gsl_sf_dawson+foreign import ccall "dawson.h gsl_sf_dawson" gsl_sf_dawson :: Double -> Double
+ lib/Numeric/GSL/Special/Debye.hs view
@@ -0,0 +1,85 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Debye+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_debye.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Debye(+  debye_1_e+, debye_1+, debye_2_e+, debye_2+, debye_3_e+, debye_3+, debye_4_e+, debye_4+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_debye_1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_debye_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_1_e :: Double -> (Double,Double)+debye_1_e x = createSFR "debye_1_e" $ gsl_sf_debye_1_e x+foreign import ccall "debye.h gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_debye_1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_debye_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_1 :: Double -> Double+debye_1 = gsl_sf_debye_1+foreign import ccall "debye.h gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double++-- | wrapper for int gsl_sf_debye_2_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_debye_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_2_e :: Double -> (Double,Double)+debye_2_e x = createSFR "debye_2_e" $ gsl_sf_debye_2_e x+foreign import ccall "debye.h gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_debye_2(double x);+--+--   <http://www.google.com/search?q=gsl_sf_debye_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_2 :: Double -> Double+debye_2 = gsl_sf_debye_2+foreign import ccall "debye.h gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double++-- | wrapper for int gsl_sf_debye_3_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_debye_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_3_e :: Double -> (Double,Double)+debye_3_e x = createSFR "debye_3_e" $ gsl_sf_debye_3_e x+foreign import ccall "debye.h gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_debye_3(double x);+--+--   <http://www.google.com/search?q=gsl_sf_debye_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_3 :: Double -> Double+debye_3 = gsl_sf_debye_3+foreign import ccall "debye.h gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double++-- | wrapper for int gsl_sf_debye_4_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_debye_4_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_4_e :: Double -> (Double,Double)+debye_4_e x = createSFR "debye_4_e" $ gsl_sf_debye_4_e x+foreign import ccall "debye.h gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_debye_4(double x);+--+--   <http://www.google.com/search?q=gsl_sf_debye_4&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+debye_4 :: Double -> Double+debye_4 = gsl_sf_debye_4+foreign import ccall "debye.h gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double
+ lib/Numeric/GSL/Special/Dilog.hs view
@@ -0,0 +1,58 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Dilog+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_dilog.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Dilog(+  dilog_e+, dilog+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_dilog_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_dilog_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+dilog_e :: Double -> (Double,Double)+dilog_e x = createSFR "dilog_e" $ gsl_sf_dilog_e x+foreign import ccall "dilog.h gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_dilog(double x);+--+--   <http://www.google.com/search?q=gsl_sf_dilog&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+dilog :: Double -> Double+dilog = gsl_sf_dilog+foreign import ccall "dilog.h gsl_sf_dilog" gsl_sf_dilog :: Double -> Double++-- | wrapper for int gsl_sf_complex_dilog_xy_e(double x,double y,gsl_sf_result* result_re,gsl_sf_result* result_im);+--+--   <http://www.google.com/search?q=gsl_sf_complex_dilog_xy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+complex_dilog_xy_e :: Double -> Double -> Ptr Double -> (Double,Double)+complex_dilog_xy_e x y result_re = createSFR "complex_dilog_xy_e" $ gsl_sf_complex_dilog_xy_e x y result_re+foreign import ccall "dilog.h gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_complex_dilog_e(double r,double theta,gsl_sf_result* result_re,gsl_sf_result* result_im);+--+--   <http://www.google.com/search?q=gsl_sf_complex_dilog_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+complex_dilog_e :: Double -> Double -> Ptr Double -> (Double,Double)+complex_dilog_e r theta result_re = createSFR "complex_dilog_e" $ gsl_sf_complex_dilog_e r theta result_re+foreign import ccall "dilog.h gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_complex_spence_xy_e(double x,double y,gsl_sf_result* real_sp,gsl_sf_result* imag_sp);+--+--   <http://www.google.com/search?q=gsl_sf_complex_spence_xy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+complex_spence_xy_e :: Double -> Double -> Ptr Double -> (Double,Double)+complex_spence_xy_e x y real_sp = createSFR "complex_spence_xy_e" $ gsl_sf_complex_spence_xy_e x y real_sp+foreign import ccall "dilog.h gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+ lib/Numeric/GSL/Special/Elementary.hs view
@@ -0,0 +1,45 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Elementary+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_elementary.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Elementary(+  multiply_e+, multiply+, multiply_err_e+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_multiply_e(double x,double y,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_multiply_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+multiply_e :: Double -> Double -> (Double,Double)+multiply_e x y = createSFR "multiply_e" $ gsl_sf_multiply_e x y+foreign import ccall "elementary.h gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_multiply(double x,double y);+--+--   <http://www.google.com/search?q=gsl_sf_multiply&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+multiply :: Double -> Double -> Double+multiply = gsl_sf_multiply+foreign import ccall "elementary.h gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double++-- | wrapper for int gsl_sf_multiply_err_e(double x,double dx,double y,double dy,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_multiply_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+multiply_err_e :: Double -> Double -> Double -> Double -> (Double,Double)+multiply_err_e x dx y dy = createSFR "multiply_err_e" $ gsl_sf_multiply_err_e x dx y dy+foreign import ccall "elementary.h gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)
+ lib/Numeric/GSL/Special/Ellint.hs view
@@ -0,0 +1,181 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Ellint+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_ellint.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Ellint(+  ellint_Kcomp_e+, ellint_Kcomp+, ellint_Ecomp_e+, ellint_Ecomp+, ellint_F_e+, ellint_F+, ellint_E_e+, ellint_E+, ellint_P_e+, ellint_P+, ellint_D_e+, ellint_D+, ellint_RC_e+, ellint_RC+, ellint_RD_e+, ellint_RD+, ellint_RF_e+, ellint_RF+, ellint_RJ_e+, ellint_RJ+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_ellint_Kcomp_e(double k,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_Kcomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_Kcomp_e :: Double -> Precision -> (Double,Double)+ellint_Kcomp_e k mode = createSFR "ellint_Kcomp_e" $ gsl_sf_ellint_Kcomp_e k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_Kcomp(double k,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_Kcomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_Kcomp :: Double -> Precision -> Double+ellint_Kcomp k mode = gsl_sf_ellint_Kcomp k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_Ecomp_e(double k,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_Ecomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_Ecomp_e :: Double -> Precision -> (Double,Double)+ellint_Ecomp_e k mode = createSFR "ellint_Ecomp_e" $ gsl_sf_ellint_Ecomp_e k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_Ecomp(double k,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_Ecomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_Ecomp :: Double -> Precision -> Double+ellint_Ecomp k mode = gsl_sf_ellint_Ecomp k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_F_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_F_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_F_e :: Double -> Double -> Precision -> (Double,Double)+ellint_F_e phi k mode = createSFR "ellint_F_e" $ gsl_sf_ellint_F_e phi k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_F(double phi,double k,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_F&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_F :: Double -> Double -> Precision -> Double+ellint_F phi k mode = gsl_sf_ellint_F phi k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_E_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_E_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_E_e :: Double -> Double -> Precision -> (Double,Double)+ellint_E_e phi k mode = createSFR "ellint_E_e" $ gsl_sf_ellint_E_e phi k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_E(double phi,double k,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_E&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_E :: Double -> Double -> Precision -> Double+ellint_E phi k mode = gsl_sf_ellint_E phi k  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_P_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_P_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_P_e :: Double -> Double -> Double -> Precision -> (Double,Double)+ellint_P_e phi k n mode = createSFR "ellint_P_e" $ gsl_sf_ellint_P_e phi k n  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_P(double phi,double k,double n,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_P&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_P :: Double -> Double -> Double -> Precision -> Double+ellint_P phi k n mode = gsl_sf_ellint_P phi k n  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_D_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_D_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_D_e :: Double -> Double -> Double -> Precision -> (Double,Double)+ellint_D_e phi k n mode = createSFR "ellint_D_e" $ gsl_sf_ellint_D_e phi k n  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_D(double phi,double k,double n,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_D&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_D :: Double -> Double -> Double -> Precision -> Double+ellint_D phi k n mode = gsl_sf_ellint_D phi k n  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_RC_e(double x,double y,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RC_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RC_e :: Double -> Double -> Precision -> (Double,Double)+ellint_RC_e x y mode = createSFR "ellint_RC_e" $ gsl_sf_ellint_RC_e x y  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_RC(double x,double y,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RC&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RC :: Double -> Double -> Precision -> Double+ellint_RC x y mode = gsl_sf_ellint_RC x y  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_RD_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RD_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RD_e :: Double -> Double -> Double -> Precision -> (Double,Double)+ellint_RD_e x y z mode = createSFR "ellint_RD_e" $ gsl_sf_ellint_RD_e x y z  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_RD(double x,double y,double z,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RD&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RD :: Double -> Double -> Double -> Precision -> Double+ellint_RD x y z mode = gsl_sf_ellint_RD x y z  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_RF_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RF_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RF_e :: Double -> Double -> Double -> Precision -> (Double,Double)+ellint_RF_e x y z mode = createSFR "ellint_RF_e" $ gsl_sf_ellint_RF_e x y z  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_RF(double x,double y,double z,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RF&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RF :: Double -> Double -> Double -> Precision -> Double+ellint_RF x y z mode = gsl_sf_ellint_RF x y z  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double++-- | wrapper for int gsl_sf_ellint_RJ_e(double x,double y,double z,double p,gsl_mode_t mode,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RJ_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RJ_e :: Double -> Double -> Double -> Double -> Precision -> (Double,Double)+ellint_RJ_e x y z p mode = createSFR "ellint_RJ_e" $ gsl_sf_ellint_RJ_e x y z p  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_ellint_RJ(double x,double y,double z,double p,gsl_mode_t mode);+--+--   <http://www.google.com/search?q=gsl_sf_ellint_RJ&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ellint_RJ :: Double -> Double -> Double -> Double -> Precision -> Double+ellint_RJ x y z p mode = gsl_sf_ellint_RJ x y z p  (precCode mode)+foreign import ccall "ellint.h gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double
+ lib/Numeric/GSL/Special/Erf.hs view
@@ -0,0 +1,117 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Erf+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_erf.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Erf(+  erfc_e+, erfc+, log_erfc_e+, log_erfc+, erf_e+, erf+, erf_Z_e+, erf_Q_e+, erf_Z+, erf_Q+, hazard_e+, hazard+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_erfc_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_erfc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erfc_e :: Double -> (Double,Double)+erfc_e x = createSFR "erfc_e" $ gsl_sf_erfc_e x+foreign import ccall "erf.h gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_erfc(double x);+--+--   <http://www.google.com/search?q=gsl_sf_erfc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erfc :: Double -> Double+erfc = gsl_sf_erfc+foreign import ccall "erf.h gsl_sf_erfc" gsl_sf_erfc :: Double -> Double++-- | wrapper for int gsl_sf_log_erfc_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_log_erfc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+log_erfc_e :: Double -> (Double,Double)+log_erfc_e x = createSFR "log_erfc_e" $ gsl_sf_log_erfc_e x+foreign import ccall "erf.h gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_log_erfc(double x);+--+--   <http://www.google.com/search?q=gsl_sf_log_erfc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+log_erfc :: Double -> Double+log_erfc = gsl_sf_log_erfc+foreign import ccall "erf.h gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double++-- | wrapper for int gsl_sf_erf_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_erf_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erf_e :: Double -> (Double,Double)+erf_e x = createSFR "erf_e" $ gsl_sf_erf_e x+foreign import ccall "erf.h gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_erf(double x);+--+--   <http://www.google.com/search?q=gsl_sf_erf&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erf :: Double -> Double+erf = gsl_sf_erf+foreign import ccall "erf.h gsl_sf_erf" gsl_sf_erf :: Double -> Double++-- | wrapper for int gsl_sf_erf_Z_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_erf_Z_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erf_Z_e :: Double -> (Double,Double)+erf_Z_e x = createSFR "erf_Z_e" $ gsl_sf_erf_Z_e x+foreign import ccall "erf.h gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_erf_Q_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_erf_Q_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erf_Q_e :: Double -> (Double,Double)+erf_Q_e x = createSFR "erf_Q_e" $ gsl_sf_erf_Q_e x+foreign import ccall "erf.h gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_erf_Z(double x);+--+--   <http://www.google.com/search?q=gsl_sf_erf_Z&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erf_Z :: Double -> Double+erf_Z = gsl_sf_erf_Z+foreign import ccall "erf.h gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double++-- | wrapper for double gsl_sf_erf_Q(double x);+--+--   <http://www.google.com/search?q=gsl_sf_erf_Q&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+erf_Q :: Double -> Double+erf_Q = gsl_sf_erf_Q+foreign import ccall "erf.h gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double++-- | wrapper for int gsl_sf_hazard_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hazard_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hazard_e :: Double -> (Double,Double)+hazard_e x = createSFR "hazard_e" $ gsl_sf_hazard_e x+foreign import ccall "erf.h gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hazard(double x);+--+--   <http://www.google.com/search?q=gsl_sf_hazard&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hazard :: Double -> Double+hazard = gsl_sf_hazard+foreign import ccall "erf.h gsl_sf_hazard" gsl_sf_hazard :: Double -> Double
+ lib/Numeric/GSL/Special/Exp.hs view
@@ -0,0 +1,129 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Exp+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.gnu.org/software/gsl/manual/html_node/Exponential-Functions.html>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Exp(+  exp_e+, Numeric.GSL.Special.Exp.exp+, exp_e10_e+, exp_mult_e+, exp_mult+, exp_mult_e10_e+, expm1_e+, expm1+, exprel_e+, exprel+, exprel_2_e+, exprel_2+, exprel_n_e+, exprel_n+, exp_err_e+, exp_err_e10_e+, exp_mult_err_e+, exp_mult_err_e10_e+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_exp_e(double x,gsl_sf_result* result);+exp_e :: Double -> (Double,Double)+exp_e x = createSFR "exp_e" $ gsl_sf_exp_e x+foreign import ccall "exp.h gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_exp(double x);+exp :: Double -> Double+exp = gsl_sf_exp+foreign import ccall "exp.h gsl_sf_exp" gsl_sf_exp :: Double -> Double++-- | wrapper for int gsl_sf_exp_e10_e(double x,gsl_sf_result_e10* result);+exp_e10_e :: Double -> (Double,Int,Double)+exp_e10_e x = createSFR_E10 "exp_e10_e" $ gsl_sf_exp_e10_e x+foreign import ccall "exp.h gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO(Int)++-- | wrapper for int gsl_sf_exp_mult_e(double x,double y,gsl_sf_result* result);+exp_mult_e :: Double -> Double -> (Double,Double)+exp_mult_e x y = createSFR "exp_mult_e" $ gsl_sf_exp_mult_e x y+foreign import ccall "exp.h gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_exp_mult(double x,double y);+exp_mult :: Double -> Double -> Double+exp_mult = gsl_sf_exp_mult+foreign import ccall "exp.h gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double++-- | wrapper for int gsl_sf_exp_mult_e10_e(double x,double y,gsl_sf_result_e10* result);+exp_mult_e10_e :: Double -> Double -> (Double,Int,Double)+exp_mult_e10_e x y = createSFR_E10 "exp_mult_e10_e" $ gsl_sf_exp_mult_e10_e x y+foreign import ccall "exp.h gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO(Int)++-- | wrapper for int gsl_sf_expm1_e(double x,gsl_sf_result* result);+expm1_e :: Double -> (Double,Double)+expm1_e x = createSFR "expm1_e" $ gsl_sf_expm1_e x+foreign import ccall "exp.h gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expm1(double x);+expm1 :: Double -> Double+expm1 = gsl_sf_expm1+foreign import ccall "exp.h gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double++-- | wrapper for int gsl_sf_exprel_e(double x,gsl_sf_result* result);+exprel_e :: Double -> (Double,Double)+exprel_e x = createSFR "exprel_e" $ gsl_sf_exprel_e x+foreign import ccall "exp.h gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_exprel(double x);+exprel :: Double -> Double+exprel = gsl_sf_exprel+foreign import ccall "exp.h gsl_sf_exprel" gsl_sf_exprel :: Double -> Double++-- | wrapper for int gsl_sf_exprel_2_e(double x,gsl_sf_result* result);+exprel_2_e :: Double -> (Double,Double)+exprel_2_e x = createSFR "exprel_2_e" $ gsl_sf_exprel_2_e x+foreign import ccall "exp.h gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_exprel_2(double x);+exprel_2 :: Double -> Double+exprel_2 = gsl_sf_exprel_2+foreign import ccall "exp.h gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double++-- | wrapper for int gsl_sf_exprel_n_e(int n,double x,gsl_sf_result* result);+exprel_n_e :: Int -> Double -> (Double,Double)+exprel_n_e n x = createSFR "exprel_n_e" $ gsl_sf_exprel_n_e n x+foreign import ccall "exp.h gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_exprel_n(int n,double x);+exprel_n :: Int -> Double -> Double+exprel_n = gsl_sf_exprel_n+foreign import ccall "exp.h gsl_sf_exprel_n" gsl_sf_exprel_n :: Int -> Double -> Double++-- | wrapper for int gsl_sf_exp_err_e(double x,double dx,gsl_sf_result* result);+exp_err_e :: Double -> Double -> (Double,Double)+exp_err_e x dx = createSFR "exp_err_e" $ gsl_sf_exp_err_e x dx+foreign import ccall "exp.h gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_exp_err_e10_e(double x,double dx,gsl_sf_result_e10* result);+exp_err_e10_e :: Double -> Double -> (Double,Int,Double)+exp_err_e10_e x dx = createSFR_E10 "exp_err_e10_e" $ gsl_sf_exp_err_e10_e x dx+foreign import ccall "exp.h gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO(Int)++-- | wrapper for int gsl_sf_exp_mult_err_e(double x,double dx,double y,double dy,gsl_sf_result* result);+exp_mult_err_e :: Double -> Double -> Double -> Double -> (Double,Double)+exp_mult_err_e x dx y dy = createSFR "exp_mult_err_e" $ gsl_sf_exp_mult_err_e x dx y dy+foreign import ccall "exp.h gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_exp_mult_err_e10_e(double x,double dx,double y,double dy,gsl_sf_result_e10* result);+exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> (Double,Int,Double)+exp_mult_err_e10_e x dx y dy = createSFR_E10 "exp_mult_err_e10_e" $ gsl_sf_exp_mult_err_e10_e x dx y dy+foreign import ccall "exp.h gsl_sf_exp_mult_err_e10_e" gsl_sf_exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> Ptr () -> IO(Int)
+ lib/Numeric/GSL/Special/Expint.hs view
@@ -0,0 +1,213 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Expint+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_expint.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Expint(+  expint_E1_e+, expint_E1+, expint_E2_e+, expint_E2+, expint_E1_scaled_e+, expint_E1_scaled+, expint_E2_scaled_e+, expint_E2_scaled+, expint_Ei_e+, expint_Ei+, expint_Ei_scaled_e+, expint_Ei_scaled+, shi_e+, shi+, chi_e+, chi+, expint_3_e+, expint_3+, si_e+, si+, ci_e+, ci+, atanint_e+, atanint+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_expint_E1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E1_e :: Double -> (Double,Double)+expint_E1_e x = createSFR "expint_E1_e" $ gsl_sf_expint_E1_e x+foreign import ccall "expint.h gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expint_E1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E1 :: Double -> Double+expint_E1 = gsl_sf_expint_E1+foreign import ccall "expint.h gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double++-- | wrapper for int gsl_sf_expint_E2_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E2_e :: Double -> (Double,Double)+expint_E2_e x = createSFR "expint_E2_e" $ gsl_sf_expint_E2_e x+foreign import ccall "expint.h gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expint_E2(double x);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E2 :: Double -> Double+expint_E2 = gsl_sf_expint_E2+foreign import ccall "expint.h gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double++-- | wrapper for int gsl_sf_expint_E1_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E1_scaled_e :: Double -> (Double,Double)+expint_E1_scaled_e x = createSFR "expint_E1_scaled_e" $ gsl_sf_expint_E1_scaled_e x+foreign import ccall "expint.h gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expint_E1_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E1_scaled :: Double -> Double+expint_E1_scaled = gsl_sf_expint_E1_scaled+foreign import ccall "expint.h gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double++-- | wrapper for int gsl_sf_expint_E2_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E2_scaled_e :: Double -> (Double,Double)+expint_E2_scaled_e x = createSFR "expint_E2_scaled_e" $ gsl_sf_expint_E2_scaled_e x+foreign import ccall "expint.h gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expint_E2_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_expint_E2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_E2_scaled :: Double -> Double+expint_E2_scaled = gsl_sf_expint_E2_scaled+foreign import ccall "expint.h gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double++-- | wrapper for int gsl_sf_expint_Ei_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_expint_Ei_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_Ei_e :: Double -> (Double,Double)+expint_Ei_e x = createSFR "expint_Ei_e" $ gsl_sf_expint_Ei_e x+foreign import ccall "expint.h gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expint_Ei(double x);+--+--   <http://www.google.com/search?q=gsl_sf_expint_Ei&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_Ei :: Double -> Double+expint_Ei = gsl_sf_expint_Ei+foreign import ccall "expint.h gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double++-- | wrapper for int gsl_sf_expint_Ei_scaled_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_expint_Ei_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_Ei_scaled_e :: Double -> (Double,Double)+expint_Ei_scaled_e x = createSFR "expint_Ei_scaled_e" $ gsl_sf_expint_Ei_scaled_e x+foreign import ccall "expint.h gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expint_Ei_scaled(double x);+--+--   <http://www.google.com/search?q=gsl_sf_expint_Ei_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_Ei_scaled :: Double -> Double+expint_Ei_scaled = gsl_sf_expint_Ei_scaled+foreign import ccall "expint.h gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double++-- | wrapper for int gsl_sf_Shi_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_Shi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+shi_e :: Double -> (Double,Double)+shi_e x = createSFR "shi_e" $ gsl_sf_Shi_e x+foreign import ccall "expint.h gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_Shi(double x);+--+--   <http://www.google.com/search?q=gsl_sf_Shi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+shi :: Double -> Double+shi = gsl_sf_Shi+foreign import ccall "expint.h gsl_sf_Shi" gsl_sf_Shi :: Double -> Double++-- | wrapper for int gsl_sf_Chi_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_Chi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+chi_e :: Double -> (Double,Double)+chi_e x = createSFR "chi_e" $ gsl_sf_Chi_e x+foreign import ccall "expint.h gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_Chi(double x);+--+--   <http://www.google.com/search?q=gsl_sf_Chi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+chi :: Double -> Double+chi = gsl_sf_Chi+foreign import ccall "expint.h gsl_sf_Chi" gsl_sf_Chi :: Double -> Double++-- | wrapper for int gsl_sf_expint_3_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_expint_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_3_e :: Double -> (Double,Double)+expint_3_e x = createSFR "expint_3_e" $ gsl_sf_expint_3_e x+foreign import ccall "expint.h gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_expint_3(double x);+--+--   <http://www.google.com/search?q=gsl_sf_expint_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+expint_3 :: Double -> Double+expint_3 = gsl_sf_expint_3+foreign import ccall "expint.h gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double++-- | wrapper for int gsl_sf_Si_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_Si_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+si_e :: Double -> (Double,Double)+si_e x = createSFR "si_e" $ gsl_sf_Si_e x+foreign import ccall "expint.h gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_Si(double x);+--+--   <http://www.google.com/search?q=gsl_sf_Si&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+si :: Double -> Double+si = gsl_sf_Si+foreign import ccall "expint.h gsl_sf_Si" gsl_sf_Si :: Double -> Double++-- | wrapper for int gsl_sf_Ci_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_Ci_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ci_e :: Double -> (Double,Double)+ci_e x = createSFR "ci_e" $ gsl_sf_Ci_e x+foreign import ccall "expint.h gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_Ci(double x);+--+--   <http://www.google.com/search?q=gsl_sf_Ci&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+ci :: Double -> Double+ci = gsl_sf_Ci+foreign import ccall "expint.h gsl_sf_Ci" gsl_sf_Ci :: Double -> Double++-- | wrapper for int gsl_sf_atanint_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_atanint_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+atanint_e :: Double -> (Double,Double)+atanint_e x = createSFR "atanint_e" $ gsl_sf_atanint_e x+foreign import ccall "expint.h gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_atanint(double x);+--+--   <http://www.google.com/search?q=gsl_sf_atanint&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+atanint :: Double -> Double+atanint = gsl_sf_atanint+foreign import ccall "expint.h gsl_sf_atanint" gsl_sf_atanint :: Double -> Double
+ lib/Numeric/GSL/Special/Fermi_dirac.hs view
@@ -0,0 +1,165 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Fermi_dirac+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_fermi_dirac.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Fermi_dirac(+  fermi_dirac_m1_e+, fermi_dirac_m1+, fermi_dirac_0_e+, fermi_dirac_0+, fermi_dirac_1_e+, fermi_dirac_1+, fermi_dirac_2_e+, fermi_dirac_2+, fermi_dirac_int_e+, fermi_dirac_int+, fermi_dirac_mhalf_e+, fermi_dirac_mhalf+, fermi_dirac_half_e+, fermi_dirac_half+, fermi_dirac_3half_e+, fermi_dirac_3half+, fermi_dirac_inc_0_e+, fermi_dirac_inc_0+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_fermi_dirac_m1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_m1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_m1_e :: Double -> (Double,Double)+fermi_dirac_m1_e x = createSFR "fermi_dirac_m1_e" $ gsl_sf_fermi_dirac_m1_e x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_m1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_m1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_m1 :: Double -> Double+fermi_dirac_m1 = gsl_sf_fermi_dirac_m1+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_0_e :: Double -> (Double,Double)+fermi_dirac_0_e x = createSFR "fermi_dirac_0_e" $ gsl_sf_fermi_dirac_0_e x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_0 :: Double -> Double+fermi_dirac_0 = gsl_sf_fermi_dirac_0+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_1_e :: Double -> (Double,Double)+fermi_dirac_1_e x = createSFR "fermi_dirac_1_e" $ gsl_sf_fermi_dirac_1_e x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_1 :: Double -> Double+fermi_dirac_1 = gsl_sf_fermi_dirac_1+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_2_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_2_e :: Double -> (Double,Double)+fermi_dirac_2_e x = createSFR "fermi_dirac_2_e" $ gsl_sf_fermi_dirac_2_e x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_2(double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_2 :: Double -> Double+fermi_dirac_2 = gsl_sf_fermi_dirac_2+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_int_e(int j,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_int_e :: Int -> Double -> (Double,Double)+fermi_dirac_int_e j x = createSFR "fermi_dirac_int_e" $ gsl_sf_fermi_dirac_int_e j x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_int(int j,double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_int :: Int -> Double -> Double+fermi_dirac_int = gsl_sf_fermi_dirac_int+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: Int -> Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_mhalf_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_mhalf_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_mhalf_e :: Double -> (Double,Double)+fermi_dirac_mhalf_e x = createSFR "fermi_dirac_mhalf_e" $ gsl_sf_fermi_dirac_mhalf_e x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_mhalf(double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_mhalf&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_mhalf :: Double -> Double+fermi_dirac_mhalf = gsl_sf_fermi_dirac_mhalf+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_half_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_half_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_half_e :: Double -> (Double,Double)+fermi_dirac_half_e x = createSFR "fermi_dirac_half_e" $ gsl_sf_fermi_dirac_half_e x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_half(double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_half&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_half :: Double -> Double+fermi_dirac_half = gsl_sf_fermi_dirac_half+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_3half_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_3half_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_3half_e :: Double -> (Double,Double)+fermi_dirac_3half_e x = createSFR "fermi_dirac_3half_e" $ gsl_sf_fermi_dirac_3half_e x+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_3half(double x);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_3half&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_3half :: Double -> Double+fermi_dirac_3half = gsl_sf_fermi_dirac_3half+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double++-- | wrapper for int gsl_sf_fermi_dirac_inc_0_e(double x,double b,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_inc_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_inc_0_e :: Double -> Double -> (Double,Double)+fermi_dirac_inc_0_e x b = createSFR "fermi_dirac_inc_0_e" $ gsl_sf_fermi_dirac_inc_0_e x b+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fermi_dirac_inc_0(double x,double b);+--+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_inc_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fermi_dirac_inc_0 :: Double -> Double -> Double+fermi_dirac_inc_0 = gsl_sf_fermi_dirac_inc_0+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0" gsl_sf_fermi_dirac_inc_0 :: Double -> Double -> Double
+ lib/Numeric/GSL/Special/Gamma.hs view
@@ -0,0 +1,362 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Gamma+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_gamma.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Gamma(+  lngamma_e+, lngamma+, gamma_e+, gamma+, gammastar_e+, gammastar+, gammainv_e+, gammainv+, taylorcoeff_e+, taylorcoeff+, fact_e+, fact+, doublefact_e+, doublefact+, lnfact_e+, lnfact+, lndoublefact_e+, lndoublefact+, lnchoose_e+, lnchoose+, choose_e+, choose+, lnpoch_e+, lnpoch+, poch_e+, poch+, pochrel_e+, pochrel+, gamma_inc_Q_e+, gamma_inc_Q+, gamma_inc_P_e+, gamma_inc_P+, gamma_inc_e+, gamma_inc+, lnbeta_e+, lnbeta+, beta_e+, beta+, beta_inc_e+, beta_inc+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_lngamma_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lngamma_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lngamma_e :: Double -> (Double,Double)+lngamma_e x = createSFR "lngamma_e" $ gsl_sf_lngamma_e x+foreign import ccall "gamma.h gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lngamma(double x);+--+--   <http://www.google.com/search?q=gsl_sf_lngamma&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lngamma :: Double -> Double+lngamma = gsl_sf_lngamma+foreign import ccall "gamma.h gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double++-- | wrapper for int gsl_sf_lngamma_sgn_e(double x,gsl_sf_result* result_lg,double* sgn);+--+--   <http://www.google.com/search?q=gsl_sf_lngamma_sgn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lngamma_sgn_e :: Double -> Ptr Double -> Ptr Double -> Int+lngamma_sgn_e = gsl_sf_lngamma_sgn_e+foreign import ccall "gamma.h gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_gamma_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gamma_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma_e :: Double -> (Double,Double)+gamma_e x = createSFR "gamma_e" $ gsl_sf_gamma_e x+foreign import ccall "gamma.h gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gamma(double x);+--+--   <http://www.google.com/search?q=gsl_sf_gamma&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma :: Double -> Double+gamma = gsl_sf_gamma+foreign import ccall "gamma.h gsl_sf_gamma" gsl_sf_gamma :: Double -> Double++-- | wrapper for int gsl_sf_gammastar_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gammastar_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gammastar_e :: Double -> (Double,Double)+gammastar_e x = createSFR "gammastar_e" $ gsl_sf_gammastar_e x+foreign import ccall "gamma.h gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gammastar(double x);+--+--   <http://www.google.com/search?q=gsl_sf_gammastar&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gammastar :: Double -> Double+gammastar = gsl_sf_gammastar+foreign import ccall "gamma.h gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double++-- | wrapper for int gsl_sf_gammainv_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gammainv_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gammainv_e :: Double -> (Double,Double)+gammainv_e x = createSFR "gammainv_e" $ gsl_sf_gammainv_e x+foreign import ccall "gamma.h gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gammainv(double x);+--+--   <http://www.google.com/search?q=gsl_sf_gammainv&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gammainv :: Double -> Double+gammainv = gsl_sf_gammainv+foreign import ccall "gamma.h gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double++-- | wrapper for int gsl_sf_lngamma_complex_e(double zr,double zi,gsl_sf_result* lnr,gsl_sf_result* arg);+--+--   <http://www.google.com/search?q=gsl_sf_lngamma_complex_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lngamma_complex_e :: Double -> Double -> Ptr Double -> (Double,Double)+lngamma_complex_e zr zi lnr = createSFR "lngamma_complex_e" $ gsl_sf_lngamma_complex_e zr zi lnr+foreign import ccall "gamma.h gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_taylorcoeff_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_taylorcoeff_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+taylorcoeff_e :: Int -> Double -> (Double,Double)+taylorcoeff_e n x = createSFR "taylorcoeff_e" $ gsl_sf_taylorcoeff_e n x+foreign import ccall "gamma.h gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_taylorcoeff(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_taylorcoeff&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+taylorcoeff :: Int -> Double -> Double+taylorcoeff = gsl_sf_taylorcoeff+foreign import ccall "gamma.h gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: Int -> Double -> Double++-- | wrapper for int gsl_sf_fact_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_fact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fact_e :: Int -> (Double,Double)+fact_e n = createSFR "fact_e" $ gsl_sf_fact_e n+foreign import ccall "gamma.h gsl_sf_fact_e" gsl_sf_fact_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_fact(int n);+--+--   <http://www.google.com/search?q=gsl_sf_fact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+fact :: Int -> Double+fact = gsl_sf_fact+foreign import ccall "gamma.h gsl_sf_fact" gsl_sf_fact :: Int -> Double++-- | wrapper for int gsl_sf_doublefact_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_doublefact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+doublefact_e :: Int -> (Double,Double)+doublefact_e n = createSFR "doublefact_e" $ gsl_sf_doublefact_e n+foreign import ccall "gamma.h gsl_sf_doublefact_e" gsl_sf_doublefact_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_doublefact(int n);+--+--   <http://www.google.com/search?q=gsl_sf_doublefact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+doublefact :: Int -> Double+doublefact = gsl_sf_doublefact+foreign import ccall "gamma.h gsl_sf_doublefact" gsl_sf_doublefact :: Int -> Double++-- | wrapper for int gsl_sf_lnfact_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lnfact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnfact_e :: Int -> (Double,Double)+lnfact_e n = createSFR "lnfact_e" $ gsl_sf_lnfact_e n+foreign import ccall "gamma.h gsl_sf_lnfact_e" gsl_sf_lnfact_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lnfact(int n);+--+--   <http://www.google.com/search?q=gsl_sf_lnfact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnfact :: Int -> Double+lnfact = gsl_sf_lnfact+foreign import ccall "gamma.h gsl_sf_lnfact" gsl_sf_lnfact :: Int -> Double++-- | wrapper for int gsl_sf_lndoublefact_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lndoublefact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lndoublefact_e :: Int -> (Double,Double)+lndoublefact_e n = createSFR "lndoublefact_e" $ gsl_sf_lndoublefact_e n+foreign import ccall "gamma.h gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lndoublefact(int n);+--+--   <http://www.google.com/search?q=gsl_sf_lndoublefact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lndoublefact :: Int -> Double+lndoublefact = gsl_sf_lndoublefact+foreign import ccall "gamma.h gsl_sf_lndoublefact" gsl_sf_lndoublefact :: Int -> Double++-- | wrapper for int gsl_sf_lnchoose_e(int n,int m,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lnchoose_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnchoose_e :: Int -> Int -> (Double,Double)+lnchoose_e n m = createSFR "lnchoose_e" $ gsl_sf_lnchoose_e n m+foreign import ccall "gamma.h gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: Int -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lnchoose(int n,int m);+--+--   <http://www.google.com/search?q=gsl_sf_lnchoose&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnchoose :: Int -> Int -> Double+lnchoose = gsl_sf_lnchoose+foreign import ccall "gamma.h gsl_sf_lnchoose" gsl_sf_lnchoose :: Int -> Int -> Double++-- | wrapper for int gsl_sf_choose_e(int n,int m,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_choose_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+choose_e :: Int -> Int -> (Double,Double)+choose_e n m = createSFR "choose_e" $ gsl_sf_choose_e n m+foreign import ccall "gamma.h gsl_sf_choose_e" gsl_sf_choose_e :: Int -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_choose(int n,int m);+--+--   <http://www.google.com/search?q=gsl_sf_choose&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+choose :: Int -> Int -> Double+choose = gsl_sf_choose+foreign import ccall "gamma.h gsl_sf_choose" gsl_sf_choose :: Int -> Int -> Double++-- | wrapper for int gsl_sf_lnpoch_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lnpoch_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnpoch_e :: Double -> Double -> (Double,Double)+lnpoch_e a x = createSFR "lnpoch_e" $ gsl_sf_lnpoch_e a x+foreign import ccall "gamma.h gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lnpoch(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_lnpoch&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnpoch :: Double -> Double -> Double+lnpoch = gsl_sf_lnpoch+foreign import ccall "gamma.h gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double++-- | wrapper for int gsl_sf_lnpoch_sgn_e(double a,double x,gsl_sf_result* result,double* sgn);+--+--   <http://www.google.com/search?q=gsl_sf_lnpoch_sgn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnpoch_sgn_e :: Double -> Double -> Ptr Double -> Ptr Double -> Int+lnpoch_sgn_e = gsl_sf_lnpoch_sgn_e+foreign import ccall "gamma.h gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_poch_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_poch_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+poch_e :: Double -> Double -> (Double,Double)+poch_e a x = createSFR "poch_e" $ gsl_sf_poch_e a x+foreign import ccall "gamma.h gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_poch(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_poch&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+poch :: Double -> Double -> Double+poch = gsl_sf_poch+foreign import ccall "gamma.h gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double++-- | wrapper for int gsl_sf_pochrel_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_pochrel_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+pochrel_e :: Double -> Double -> (Double,Double)+pochrel_e a x = createSFR "pochrel_e" $ gsl_sf_pochrel_e a x+foreign import ccall "gamma.h gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_pochrel(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_pochrel&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+pochrel :: Double -> Double -> Double+pochrel = gsl_sf_pochrel+foreign import ccall "gamma.h gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double++-- | wrapper for int gsl_sf_gamma_inc_Q_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_Q_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma_inc_Q_e :: Double -> Double -> (Double,Double)+gamma_inc_Q_e a x = createSFR "gamma_inc_Q_e" $ gsl_sf_gamma_inc_Q_e a x+foreign import ccall "gamma.h gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gamma_inc_Q(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_Q&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma_inc_Q :: Double -> Double -> Double+gamma_inc_Q = gsl_sf_gamma_inc_Q+foreign import ccall "gamma.h gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double++-- | wrapper for int gsl_sf_gamma_inc_P_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_P_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma_inc_P_e :: Double -> Double -> (Double,Double)+gamma_inc_P_e a x = createSFR "gamma_inc_P_e" $ gsl_sf_gamma_inc_P_e a x+foreign import ccall "gamma.h gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gamma_inc_P(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_P&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma_inc_P :: Double -> Double -> Double+gamma_inc_P = gsl_sf_gamma_inc_P+foreign import ccall "gamma.h gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double++-- | wrapper for int gsl_sf_gamma_inc_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma_inc_e :: Double -> Double -> (Double,Double)+gamma_inc_e a x = createSFR "gamma_inc_e" $ gsl_sf_gamma_inc_e a x+foreign import ccall "gamma.h gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gamma_inc(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_gamma_inc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gamma_inc :: Double -> Double -> Double+gamma_inc = gsl_sf_gamma_inc+foreign import ccall "gamma.h gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double++-- | wrapper for int gsl_sf_lnbeta_e(double a,double b,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lnbeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnbeta_e :: Double -> Double -> (Double,Double)+lnbeta_e a b = createSFR "lnbeta_e" $ gsl_sf_lnbeta_e a b+foreign import ccall "gamma.h gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lnbeta(double a,double b);+--+--   <http://www.google.com/search?q=gsl_sf_lnbeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lnbeta :: Double -> Double -> Double+lnbeta = gsl_sf_lnbeta+foreign import ccall "gamma.h gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double++-- | wrapper for int gsl_sf_beta_e(double a,double b,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_beta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+beta_e :: Double -> Double -> (Double,Double)+beta_e a b = createSFR "beta_e" $ gsl_sf_beta_e a b+foreign import ccall "gamma.h gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_beta(double a,double b);+--+--   <http://www.google.com/search?q=gsl_sf_beta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+beta :: Double -> Double -> Double+beta = gsl_sf_beta+foreign import ccall "gamma.h gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double++-- | wrapper for int gsl_sf_beta_inc_e(double a,double b,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_beta_inc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+beta_inc_e :: Double -> Double -> Double -> (Double,Double)+beta_inc_e a b x = createSFR "beta_inc_e" $ gsl_sf_beta_inc_e a b x+foreign import ccall "gamma.h gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_beta_inc(double a,double b,double x);+--+--   <http://www.google.com/search?q=gsl_sf_beta_inc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+beta_inc :: Double -> Double -> Double -> Double+beta_inc = gsl_sf_beta_inc+foreign import ccall "gamma.h gsl_sf_beta_inc" gsl_sf_beta_inc :: Double -> Double -> Double -> Double
+ lib/Numeric/GSL/Special/Gegenbauer.hs view
@@ -0,0 +1,92 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Gegenbauer+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_gegenbauer.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Gegenbauer(+  gegenpoly_1_e+, gegenpoly_2_e+, gegenpoly_3_e+, gegenpoly_1+, gegenpoly_2+, gegenpoly_3+, gegenpoly_n_e+, gegenpoly_n+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_gegenpoly_1_e(double lambda,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_1_e :: Double -> Double -> (Double,Double)+gegenpoly_1_e lambda x = createSFR "gegenpoly_1_e" $ gsl_sf_gegenpoly_1_e lambda x+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_gegenpoly_2_e(double lambda,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_2_e :: Double -> Double -> (Double,Double)+gegenpoly_2_e lambda x = createSFR "gegenpoly_2_e" $ gsl_sf_gegenpoly_2_e lambda x+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_gegenpoly_3_e(double lambda,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_3_e :: Double -> Double -> (Double,Double)+gegenpoly_3_e lambda x = createSFR "gegenpoly_3_e" $ gsl_sf_gegenpoly_3_e lambda x+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gegenpoly_1(double lambda,double x);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_1 :: Double -> Double -> Double+gegenpoly_1 = gsl_sf_gegenpoly_1+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double++-- | wrapper for double gsl_sf_gegenpoly_2(double lambda,double x);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_2 :: Double -> Double -> Double+gegenpoly_2 = gsl_sf_gegenpoly_2+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double++-- | wrapper for double gsl_sf_gegenpoly_3(double lambda,double x);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_3 :: Double -> Double -> Double+gegenpoly_3 = gsl_sf_gegenpoly_3+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_gegenpoly_n_e(int n,double lambda,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_n_e :: Int -> Double -> Double -> (Double,Double)+gegenpoly_n_e n lambda x = createSFR "gegenpoly_n_e" $ gsl_sf_gegenpoly_n_e n lambda x+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_gegenpoly_n(int n,double lambda,double x);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_n :: Int -> Double -> Double -> Double+gegenpoly_n = gsl_sf_gegenpoly_n+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: Int -> Double -> Double -> Double++-- | wrapper for int gsl_sf_gegenpoly_array(int nmax,double lambda,double x,double* result_array);+--+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+gegenpoly_array :: Int -> Double -> Double -> Ptr Double -> Int+gegenpoly_array = gsl_sf_gegenpoly_array+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: Int -> Double -> Double -> Ptr Double -> Int
+ lib/Numeric/GSL/Special/Hyperg.hs view
@@ -0,0 +1,197 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Hyperg+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_hyperg.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Hyperg(+  hyperg_0F1_e+, hyperg_0F1+, hyperg_1F1_int_e+, hyperg_1F1_int+, hyperg_1F1_e+, hyperg_1F1+, hyperg_U_int_e+, hyperg_U_int+, hyperg_U_int_e10_e+, hyperg_U_e+, hyperg_U+, hyperg_U_e10_e+, hyperg_2F1_e+, hyperg_2F1+, hyperg_2F1_conj_e+, hyperg_2F1_conj+, hyperg_2F1_renorm_e+, hyperg_2F1_renorm+, hyperg_2F1_conj_renorm_e+, hyperg_2F1_conj_renorm+, hyperg_2F0_e+, hyperg_2F0+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_hyperg_0F1_e(double c,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_0F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_0F1_e :: Double -> Double -> (Double,Double)+hyperg_0F1_e c x = createSFR "hyperg_0F1_e" $ gsl_sf_hyperg_0F1_e c x+foreign import ccall "hyperg.h gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_0F1(double c,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_0F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_0F1 :: Double -> Double -> Double+hyperg_0F1 = gsl_sf_hyperg_0F1+foreign import ccall "hyperg.h gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_1F1_int_e(int m,int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_1F1_int_e :: Int -> Int -> Double -> (Double,Double)+hyperg_1F1_int_e m n x = createSFR "hyperg_1F1_int_e" $ gsl_sf_hyperg_1F1_int_e m n x+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_1F1_int(int m,int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_1F1_int :: Int -> Int -> Double -> Double+hyperg_1F1_int = gsl_sf_hyperg_1F1_int+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: Int -> Int -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_1F1_e(double a,double b,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_1F1_e :: Double -> Double -> Double -> (Double,Double)+hyperg_1F1_e a b x = createSFR "hyperg_1F1_e" $ gsl_sf_hyperg_1F1_e a b x+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_1F1(double a,double b,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_1F1 :: Double -> Double -> Double -> Double+hyperg_1F1 = gsl_sf_hyperg_1F1+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_U_int_e(int m,int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_U_int_e :: Int -> Int -> Double -> (Double,Double)+hyperg_U_int_e m n x = createSFR "hyperg_U_int_e" $ gsl_sf_hyperg_U_int_e m n x+foreign import ccall "hyperg.h gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_U_int(int m,int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_U_int :: Int -> Int -> Double -> Double+hyperg_U_int = gsl_sf_hyperg_U_int+foreign import ccall "hyperg.h gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: Int -> Int -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_U_int_e10_e(int m,int n,double x,gsl_sf_result_e10* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_int_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_U_int_e10_e :: Int -> Int -> Double -> (Double,Int,Double)+hyperg_U_int_e10_e m n x = createSFR_E10 "hyperg_U_int_e10_e" $ gsl_sf_hyperg_U_int_e10_e m n x+foreign import ccall "hyperg.h gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: Int -> Int -> Double -> Ptr () -> IO(Int)++-- | wrapper for int gsl_sf_hyperg_U_e(double a,double b,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_U_e :: Double -> Double -> Double -> (Double,Double)+hyperg_U_e a b x = createSFR "hyperg_U_e" $ gsl_sf_hyperg_U_e a b x+foreign import ccall "hyperg.h gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_U(double a,double b,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_U&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_U :: Double -> Double -> Double -> Double+hyperg_U = gsl_sf_hyperg_U+foreign import ccall "hyperg.h gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_U_e10_e(double a,double b,double x,gsl_sf_result_e10* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_U_e10_e :: Double -> Double -> Double -> (Double,Int,Double)+hyperg_U_e10_e a b x = createSFR_E10 "hyperg_U_e10_e" $ gsl_sf_hyperg_U_e10_e a b x+foreign import ccall "hyperg.h gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO(Int)++-- | wrapper for int gsl_sf_hyperg_2F1_e(double a,double b,double c,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1_e :: Double -> Double -> Double -> Double -> (Double,Double)+hyperg_2F1_e a b c x = createSFR "hyperg_2F1_e" $ gsl_sf_hyperg_2F1_e a b c x+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_2F1(double a,double b,double c,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1 :: Double -> Double -> Double -> Double -> Double+hyperg_2F1 = gsl_sf_hyperg_2F1+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_2F1_conj_e(double aR,double aI,double c,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> (Double,Double)+hyperg_2F1_conj_e aR aI c x = createSFR "hyperg_2F1_conj_e" $ gsl_sf_hyperg_2F1_conj_e aR aI c x+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_2F1_conj(double aR,double aI,double c,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double+hyperg_2F1_conj = gsl_sf_hyperg_2F1_conj+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_2F1_renorm_e(double a,double b,double c,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_renorm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)+hyperg_2F1_renorm_e a b c x = createSFR "hyperg_2F1_renorm_e" $ gsl_sf_hyperg_2F1_renorm_e a b c x+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_2F1_renorm(double a,double b,double c,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_renorm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double+hyperg_2F1_renorm = gsl_sf_hyperg_2F1_renorm+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_2F1_conj_renorm_e(double aR,double aI,double c,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_renorm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)+hyperg_2F1_conj_renorm_e aR aI c x = createSFR "hyperg_2F1_conj_renorm_e" $ gsl_sf_hyperg_2F1_conj_renorm_e aR aI c x+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_2F1_conj_renorm(double aR,double aI,double c,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_renorm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double+hyperg_2F1_conj_renorm = gsl_sf_hyperg_2F1_conj_renorm+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double++-- | wrapper for int gsl_sf_hyperg_2F0_e(double a,double b,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F0_e :: Double -> Double -> Double -> (Double,Double)+hyperg_2F0_e a b x = createSFR "hyperg_2F0_e" $ gsl_sf_hyperg_2F0_e a b x+foreign import ccall "hyperg.h gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hyperg_2F0(double a,double b,double x);+--+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hyperg_2F0 :: Double -> Double -> Double -> Double+hyperg_2F0 = gsl_sf_hyperg_2F0+foreign import ccall "hyperg.h gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double
+ lib/Numeric/GSL/Special/Internal.hs view
@@ -0,0 +1,68 @@+{-# OPTIONS #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Internal+Copyright   :  (c) Alberto Ruiz 2007+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Support for Special functions.++<http://www.gnu.org/software/gsl/manual/html_node/Special-Functions.html#Special-Functions>+-}+-----------------------------------------------------------------------------++module Numeric.GSL.Special.Internal (+    createSFR,+    createSFR_E10,+    Precision(..),+    Gsl_mode_t,+    Size_t,+    precCode+)+where++import Foreign+import Data.Packed.Internal(check,(//))+++data Precision = PrecDouble | PrecSingle | PrecApprox++precCode :: Precision -> Int+precCode PrecDouble = 0+precCode PrecSingle = 1+precCode PrecApprox = 2++type Gsl_mode_t = Int++type Size_t = Int++----------------------------------------------------------------+-- | access to a sf_result+createSFR :: Storable a => String -> (Ptr a -> IO Int) -> (a, a)+createSFR s f = unsafePerformIO $ do+    p <- mallocArray 2+    f p // check s+    [val,err] <- peekArray 2 p+    free p+    return (val,err)+++---------------------------------------------------------------------+-- the sf_result_e10 contains two doubles and the exponent++-- | acces to sf_result_e10+createSFR_E10 :: (Storable t2, Storable t3, Storable t1) => String -> (Ptr a -> IO Int) -> (t1, t2, t3)+createSFR_E10 s f = unsafePerformIO $ do+    let sd = sizeOf (0::Double)+    let si = sizeOf (0::Int)+    p <- mallocBytes (2*sd + si)+    f p // check s+    val <- peekByteOff p 0+    err <- peekByteOff p sd+    expo <- peekByteOff p (2*sd) +    free p+    return (val,expo,err)
+ lib/Numeric/GSL/Special/Laguerre.hs view
@@ -0,0 +1,85 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Laguerre+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_laguerre.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Laguerre(+  laguerre_1_e+, laguerre_2_e+, laguerre_3_e+, laguerre_1+, laguerre_2+, laguerre_3+, laguerre_n_e+, laguerre_n+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_laguerre_1_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_1_e :: Double -> Double -> (Double,Double)+laguerre_1_e a x = createSFR "laguerre_1_e" $ gsl_sf_laguerre_1_e a x+foreign import ccall "laguerre.h gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_laguerre_2_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_2_e :: Double -> Double -> (Double,Double)+laguerre_2_e a x = createSFR "laguerre_2_e" $ gsl_sf_laguerre_2_e a x+foreign import ccall "laguerre.h gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_laguerre_3_e(double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_3_e :: Double -> Double -> (Double,Double)+laguerre_3_e a x = createSFR "laguerre_3_e" $ gsl_sf_laguerre_3_e a x+foreign import ccall "laguerre.h gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_laguerre_1(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_1 :: Double -> Double -> Double+laguerre_1 = gsl_sf_laguerre_1+foreign import ccall "laguerre.h gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double++-- | wrapper for double gsl_sf_laguerre_2(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_2 :: Double -> Double -> Double+laguerre_2 = gsl_sf_laguerre_2+foreign import ccall "laguerre.h gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double++-- | wrapper for double gsl_sf_laguerre_3(double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_3 :: Double -> Double -> Double+laguerre_3 = gsl_sf_laguerre_3+foreign import ccall "laguerre.h gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_laguerre_n_e(int n,double a,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_n_e :: Int -> Double -> Double -> (Double,Double)+laguerre_n_e n a x = createSFR "laguerre_n_e" $ gsl_sf_laguerre_n_e n a x+foreign import ccall "laguerre.h gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_laguerre_n(int n,double a,double x);+--+--   <http://www.google.com/search?q=gsl_sf_laguerre_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+laguerre_n :: Int -> Double -> Double -> Double+laguerre_n = gsl_sf_laguerre_n+foreign import ccall "laguerre.h gsl_sf_laguerre_n" gsl_sf_laguerre_n :: Int -> Double -> Double -> Double
+ lib/Numeric/GSL/Special/Lambert.hs view
@@ -0,0 +1,53 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Lambert+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_lambert.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Lambert(+  lambert_W0_e+, lambert_W0+, lambert_Wm1_e+, lambert_Wm1+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_lambert_W0_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lambert_W0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lambert_W0_e :: Double -> (Double,Double)+lambert_W0_e x = createSFR "lambert_W0_e" $ gsl_sf_lambert_W0_e x+foreign import ccall "lambert.h gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lambert_W0(double x);+--+--   <http://www.google.com/search?q=gsl_sf_lambert_W0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lambert_W0 :: Double -> Double+lambert_W0 = gsl_sf_lambert_W0+foreign import ccall "lambert.h gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double++-- | wrapper for int gsl_sf_lambert_Wm1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_lambert_Wm1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lambert_Wm1_e :: Double -> (Double,Double)+lambert_Wm1_e x = createSFR "lambert_Wm1_e" $ gsl_sf_lambert_Wm1_e x+foreign import ccall "lambert.h gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lambert_Wm1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_lambert_Wm1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+lambert_Wm1 :: Double -> Double+lambert_Wm1 = gsl_sf_lambert_Wm1+foreign import ccall "lambert.h gsl_sf_lambert_Wm1" gsl_sf_lambert_Wm1 :: Double -> Double
+ lib/Numeric/GSL/Special/Legendre.hs view
@@ -0,0 +1,278 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Legendre+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.gnu.org/software/gsl/manual/html_node/Legendre-Functions-and-Spherical-Harmonics.html>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Legendre(+  legendre_Pl_e+, legendre_Pl+, legendre_P1_e+, legendre_P2_e+, legendre_P3_e+, legendre_P1+, legendre_P2+, legendre_P3+, legendre_Q0_e+, legendre_Q0+, legendre_Q1_e+, legendre_Q1+, legendre_Ql_e+, legendre_Ql+, legendre_Plm_e+, legendre_Plm+, legendre_sphPlm_e+, legendre_sphPlm+, legendre_array_size+, conicalP_half_e+, conicalP_half+, conicalP_mhalf_e+, conicalP_mhalf+, conicalP_0_e+, conicalP_0+, conicalP_1_e+, conicalP_1+, conicalP_sph_reg_e+, conicalP_sph_reg+, conicalP_cyl_reg_e+, conicalP_cyl_reg+, legendre_H3d_0_e+, legendre_H3d_0+, legendre_H3d_1_e+, legendre_H3d_1+, legendre_H3d_e+, legendre_H3d+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_legendre_Pl_e(int l,double x,gsl_sf_result* result);+legendre_Pl_e :: Int -> Double -> (Double,Double)+legendre_Pl_e l x = createSFR "legendre_Pl_e" $ gsl_sf_legendre_Pl_e l x+foreign import ccall "legendre.h gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_Pl(int l,double x);+legendre_Pl :: Int -> Double -> Double+legendre_Pl = gsl_sf_legendre_Pl+foreign import ccall "legendre.h gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: Int -> Double -> Double++-- | wrapper for int gsl_sf_legendre_Pl_array(int lmax,double x,double* result_array);+legendre_Pl_array :: Int -> Double -> Ptr Double -> Int+legendre_Pl_array = gsl_sf_legendre_Pl_array+foreign import ccall "legendre.h gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_legendre_Pl_deriv_array(int lmax,double x,double* result_array,double* result_deriv_array);+legendre_Pl_deriv_array :: Int -> Double -> Ptr Double -> Ptr Double -> Int+legendre_Pl_deriv_array = gsl_sf_legendre_Pl_deriv_array+foreign import ccall "legendre.h gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: Int -> Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_legendre_P1_e(double x,gsl_sf_result* result);+legendre_P1_e :: Double -> (Double,Double)+legendre_P1_e x = createSFR "legendre_P1_e" $ gsl_sf_legendre_P1_e x+foreign import ccall "legendre.h gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_legendre_P2_e(double x,gsl_sf_result* result);+legendre_P2_e :: Double -> (Double,Double)+legendre_P2_e x = createSFR "legendre_P2_e" $ gsl_sf_legendre_P2_e x+foreign import ccall "legendre.h gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_legendre_P3_e(double x,gsl_sf_result* result);+legendre_P3_e :: Double -> (Double,Double)+legendre_P3_e x = createSFR "legendre_P3_e" $ gsl_sf_legendre_P3_e x+foreign import ccall "legendre.h gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_P1(double x);+legendre_P1 :: Double -> Double+legendre_P1 = gsl_sf_legendre_P1+foreign import ccall "legendre.h gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double++-- | wrapper for double gsl_sf_legendre_P2(double x);+legendre_P2 :: Double -> Double+legendre_P2 = gsl_sf_legendre_P2+foreign import ccall "legendre.h gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double++-- | wrapper for double gsl_sf_legendre_P3(double x);+legendre_P3 :: Double -> Double+legendre_P3 = gsl_sf_legendre_P3+foreign import ccall "legendre.h gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double++-- | wrapper for int gsl_sf_legendre_Q0_e(double x,gsl_sf_result* result);+legendre_Q0_e :: Double -> (Double,Double)+legendre_Q0_e x = createSFR "legendre_Q0_e" $ gsl_sf_legendre_Q0_e x+foreign import ccall "legendre.h gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_Q0(double x);+legendre_Q0 :: Double -> Double+legendre_Q0 = gsl_sf_legendre_Q0+foreign import ccall "legendre.h gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double++-- | wrapper for int gsl_sf_legendre_Q1_e(double x,gsl_sf_result* result);+legendre_Q1_e :: Double -> (Double,Double)+legendre_Q1_e x = createSFR "legendre_Q1_e" $ gsl_sf_legendre_Q1_e x+foreign import ccall "legendre.h gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_Q1(double x);+legendre_Q1 :: Double -> Double+legendre_Q1 = gsl_sf_legendre_Q1+foreign import ccall "legendre.h gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double++-- | wrapper for int gsl_sf_legendre_Ql_e(int l,double x,gsl_sf_result* result);+legendre_Ql_e :: Int -> Double -> (Double,Double)+legendre_Ql_e l x = createSFR "legendre_Ql_e" $ gsl_sf_legendre_Ql_e l x+foreign import ccall "legendre.h gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_Ql(int l,double x);+legendre_Ql :: Int -> Double -> Double+legendre_Ql = gsl_sf_legendre_Ql+foreign import ccall "legendre.h gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: Int -> Double -> Double++-- | wrapper for int gsl_sf_legendre_Plm_e(int l,int m,double x,gsl_sf_result* result);+legendre_Plm_e :: Int -> Int -> Double -> (Double,Double)+legendre_Plm_e l m x = createSFR "legendre_Plm_e" $ gsl_sf_legendre_Plm_e l m x+foreign import ccall "legendre.h gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_Plm(int l,int m,double x);+legendre_Plm :: Int -> Int -> Double -> Double+legendre_Plm = gsl_sf_legendre_Plm+foreign import ccall "legendre.h gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: Int -> Int -> Double -> Double++-- | wrapper for int gsl_sf_legendre_Plm_array(int lmax,int m,double x,double* result_array);+legendre_Plm_array :: Int -> Int -> Double -> Ptr Double -> Int+legendre_Plm_array = gsl_sf_legendre_Plm_array+foreign import ccall "legendre.h gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_legendre_Plm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);+legendre_Plm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int+legendre_Plm_deriv_array = gsl_sf_legendre_Plm_deriv_array+foreign import ccall "legendre.h gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_legendre_sphPlm_e(int l,int m,double x,gsl_sf_result* result);+legendre_sphPlm_e :: Int -> Int -> Double -> (Double,Double)+legendre_sphPlm_e l m x = createSFR "legendre_sphPlm_e" $ gsl_sf_legendre_sphPlm_e l m x+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_sphPlm(int l,int m,double x);+legendre_sphPlm :: Int -> Int -> Double -> Double+legendre_sphPlm = gsl_sf_legendre_sphPlm+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: Int -> Int -> Double -> Double++-- | wrapper for int gsl_sf_legendre_sphPlm_array(int lmax,int m,double x,double* result_array);+legendre_sphPlm_array :: Int -> Int -> Double -> Ptr Double -> Int+legendre_sphPlm_array = gsl_sf_legendre_sphPlm_array+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: Int -> Int -> Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_legendre_sphPlm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);+legendre_sphPlm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int+legendre_sphPlm_deriv_array = gsl_sf_legendre_sphPlm_deriv_array+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int++-- | wrapper for int gsl_sf_legendre_array_size(int lmax,int m);+legendre_array_size :: Int -> Int -> Int+legendre_array_size = gsl_sf_legendre_array_size+foreign import ccall "legendre.h gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: Int -> Int -> Int++-- | wrapper for int gsl_sf_conicalP_half_e(double lambda,double x,gsl_sf_result* result);+conicalP_half_e :: Double -> Double -> (Double,Double)+conicalP_half_e lambda x = createSFR "conicalP_half_e" $ gsl_sf_conicalP_half_e lambda x+foreign import ccall "legendre.h gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_conicalP_half(double lambda,double x);+conicalP_half :: Double -> Double -> Double+conicalP_half = gsl_sf_conicalP_half+foreign import ccall "legendre.h gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double++-- | wrapper for int gsl_sf_conicalP_mhalf_e(double lambda,double x,gsl_sf_result* result);+conicalP_mhalf_e :: Double -> Double -> (Double,Double)+conicalP_mhalf_e lambda x = createSFR "conicalP_mhalf_e" $ gsl_sf_conicalP_mhalf_e lambda x+foreign import ccall "legendre.h gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_conicalP_mhalf(double lambda,double x);+conicalP_mhalf :: Double -> Double -> Double+conicalP_mhalf = gsl_sf_conicalP_mhalf+foreign import ccall "legendre.h gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double++-- | wrapper for int gsl_sf_conicalP_0_e(double lambda,double x,gsl_sf_result* result);+conicalP_0_e :: Double -> Double -> (Double,Double)+conicalP_0_e lambda x = createSFR "conicalP_0_e" $ gsl_sf_conicalP_0_e lambda x+foreign import ccall "legendre.h gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_conicalP_0(double lambda,double x);+conicalP_0 :: Double -> Double -> Double+conicalP_0 = gsl_sf_conicalP_0+foreign import ccall "legendre.h gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_conicalP_1_e(double lambda,double x,gsl_sf_result* result);+conicalP_1_e :: Double -> Double -> (Double,Double)+conicalP_1_e lambda x = createSFR "conicalP_1_e" $ gsl_sf_conicalP_1_e lambda x+foreign import ccall "legendre.h gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_conicalP_1(double lambda,double x);+conicalP_1 :: Double -> Double -> Double+conicalP_1 = gsl_sf_conicalP_1+foreign import ccall "legendre.h gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_conicalP_sph_reg_e(int l,double lambda,double x,gsl_sf_result* result);+conicalP_sph_reg_e :: Int -> Double -> Double -> (Double,Double)+conicalP_sph_reg_e l lambda x = createSFR "conicalP_sph_reg_e" $ gsl_sf_conicalP_sph_reg_e l lambda x+foreign import ccall "legendre.h gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_conicalP_sph_reg(int l,double lambda,double x);+conicalP_sph_reg :: Int -> Double -> Double -> Double+conicalP_sph_reg = gsl_sf_conicalP_sph_reg+foreign import ccall "legendre.h gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: Int -> Double -> Double -> Double++-- | wrapper for int gsl_sf_conicalP_cyl_reg_e(int m,double lambda,double x,gsl_sf_result* result);+conicalP_cyl_reg_e :: Int -> Double -> Double -> (Double,Double)+conicalP_cyl_reg_e m lambda x = createSFR "conicalP_cyl_reg_e" $ gsl_sf_conicalP_cyl_reg_e m lambda x+foreign import ccall "legendre.h gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_conicalP_cyl_reg(int m,double lambda,double x);+conicalP_cyl_reg :: Int -> Double -> Double -> Double+conicalP_cyl_reg = gsl_sf_conicalP_cyl_reg+foreign import ccall "legendre.h gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: Int -> Double -> Double -> Double++-- | wrapper for int gsl_sf_legendre_H3d_0_e(double lambda,double eta,gsl_sf_result* result);+legendre_H3d_0_e :: Double -> Double -> (Double,Double)+legendre_H3d_0_e lambda eta = createSFR "legendre_H3d_0_e" $ gsl_sf_legendre_H3d_0_e lambda eta+foreign import ccall "legendre.h gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_H3d_0(double lambda,double eta);+legendre_H3d_0 :: Double -> Double -> Double+legendre_H3d_0 = gsl_sf_legendre_H3d_0+foreign import ccall "legendre.h gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_legendre_H3d_1_e(double lambda,double eta,gsl_sf_result* result);+legendre_H3d_1_e :: Double -> Double -> (Double,Double)+legendre_H3d_1_e lambda eta = createSFR "legendre_H3d_1_e" $ gsl_sf_legendre_H3d_1_e lambda eta+foreign import ccall "legendre.h gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_H3d_1(double lambda,double eta);+legendre_H3d_1 :: Double -> Double -> Double+legendre_H3d_1 = gsl_sf_legendre_H3d_1+foreign import ccall "legendre.h gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double++-- | wrapper for int gsl_sf_legendre_H3d_e(int l,double lambda,double eta,gsl_sf_result* result);+legendre_H3d_e :: Int -> Double -> Double -> (Double,Double)+legendre_H3d_e l lambda eta = createSFR "legendre_H3d_e" $ gsl_sf_legendre_H3d_e l lambda eta+foreign import ccall "legendre.h gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_legendre_H3d(int l,double lambda,double eta);+legendre_H3d :: Int -> Double -> Double -> Double+legendre_H3d = gsl_sf_legendre_H3d+foreign import ccall "legendre.h gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: Int -> Double -> Double -> Double++-- | wrapper for int gsl_sf_legendre_H3d_array(int lmax,double lambda,double eta,double* result_array);+legendre_H3d_array :: Int -> Double -> Double -> Ptr Double -> Int+legendre_H3d_array = gsl_sf_legendre_H3d_array+foreign import ccall "legendre.h gsl_sf_legendre_H3d_array" gsl_sf_legendre_H3d_array :: Int -> Double -> Double -> Ptr Double -> Int
+ lib/Numeric/GSL/Special/Log.hs view
@@ -0,0 +1,74 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Log+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.gnu.org/software/gsl/manual/html_node/Logarithm-and-Related-Functions.html>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Log(+  log_e+, Numeric.GSL.Special.Log.log+, log_abs_e+, log_abs+, log_1plusx_e+, log_1plusx+, log_1plusx_mx_e+, log_1plusx_mx+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_log_e(double x,gsl_sf_result* result);+log_e :: Double -> (Double,Double)+log_e x = createSFR "log_e" $ gsl_sf_log_e x+foreign import ccall "log.h gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_log(double x);+log :: Double -> Double+log = gsl_sf_log+foreign import ccall "log.h gsl_sf_log" gsl_sf_log :: Double -> Double++-- | wrapper for int gsl_sf_log_abs_e(double x,gsl_sf_result* result);+log_abs_e :: Double -> (Double,Double)+log_abs_e x = createSFR "log_abs_e" $ gsl_sf_log_abs_e x+foreign import ccall "log.h gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_log_abs(double x);+log_abs :: Double -> Double+log_abs = gsl_sf_log_abs+foreign import ccall "log.h gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double++-- | wrapper for int gsl_sf_complex_log_e(double zr,double zi,gsl_sf_result* lnr,gsl_sf_result* theta);+complex_log_e :: Double -> Double -> Ptr Double -> (Double,Double)+complex_log_e zr zi lnr = createSFR "complex_log_e" $ gsl_sf_complex_log_e zr zi lnr+foreign import ccall "log.h gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_log_1plusx_e(double x,gsl_sf_result* result);+log_1plusx_e :: Double -> (Double,Double)+log_1plusx_e x = createSFR "log_1plusx_e" $ gsl_sf_log_1plusx_e x+foreign import ccall "log.h gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_log_1plusx(double x);+log_1plusx :: Double -> Double+log_1plusx = gsl_sf_log_1plusx+foreign import ccall "log.h gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double++-- | wrapper for int gsl_sf_log_1plusx_mx_e(double x,gsl_sf_result* result);+log_1plusx_mx_e :: Double -> (Double,Double)+log_1plusx_mx_e x = createSFR "log_1plusx_mx_e" $ gsl_sf_log_1plusx_mx_e x+foreign import ccall "log.h gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_log_1plusx_mx(double x);+log_1plusx_mx :: Double -> Double+log_1plusx_mx = gsl_sf_log_1plusx_mx+foreign import ccall "log.h gsl_sf_log_1plusx_mx" gsl_sf_log_1plusx_mx :: Double -> Double
+ lib/Numeric/GSL/Special/Pow_int.hs view
@@ -0,0 +1,37 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Pow_int+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_pow_int.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Pow_int(+  pow_int_e+, pow_int+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_pow_int_e(double x,int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_pow_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+pow_int_e :: Double -> Int -> (Double,Double)+pow_int_e x n = createSFR "pow_int_e" $ gsl_sf_pow_int_e x n+foreign import ccall "pow_int.h gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_pow_int(double x,int n);+--+--   <http://www.google.com/search?q=gsl_sf_pow_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+pow_int :: Double -> Int -> Double+pow_int = gsl_sf_pow_int+foreign import ccall "pow_int.h gsl_sf_pow_int" gsl_sf_pow_int :: Double -> Int -> Double
+ lib/Numeric/GSL/Special/Psi.hs view
@@ -0,0 +1,117 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Psi+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_psi.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Psi(+  psi_int_e+, psi_int+, psi_e+, psi+, psi_1piy_e+, psi_1piy+, psi_1_int_e+, psi_1_int+, psi_1_e+, psi_1+, psi_n_e+, psi_n+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_psi_int_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_psi_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_int_e :: Int -> (Double,Double)+psi_int_e n = createSFR "psi_int_e" $ gsl_sf_psi_int_e n+foreign import ccall "psi.h gsl_sf_psi_int_e" gsl_sf_psi_int_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_psi_int(int n);+--+--   <http://www.google.com/search?q=gsl_sf_psi_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_int :: Int -> Double+psi_int = gsl_sf_psi_int+foreign import ccall "psi.h gsl_sf_psi_int" gsl_sf_psi_int :: Int -> Double++-- | wrapper for int gsl_sf_psi_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_psi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_e :: Double -> (Double,Double)+psi_e x = createSFR "psi_e" $ gsl_sf_psi_e x+foreign import ccall "psi.h gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_psi(double x);+--+--   <http://www.google.com/search?q=gsl_sf_psi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi :: Double -> Double+psi = gsl_sf_psi+foreign import ccall "psi.h gsl_sf_psi" gsl_sf_psi :: Double -> Double++-- | wrapper for int gsl_sf_psi_1piy_e(double y,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_psi_1piy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_1piy_e :: Double -> (Double,Double)+psi_1piy_e y = createSFR "psi_1piy_e" $ gsl_sf_psi_1piy_e y+foreign import ccall "psi.h gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_psi_1piy(double y);+--+--   <http://www.google.com/search?q=gsl_sf_psi_1piy&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_1piy :: Double -> Double+psi_1piy = gsl_sf_psi_1piy+foreign import ccall "psi.h gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double++-- | wrapper for int gsl_sf_psi_1_int_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_psi_1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_1_int_e :: Int -> (Double,Double)+psi_1_int_e n = createSFR "psi_1_int_e" $ gsl_sf_psi_1_int_e n+foreign import ccall "psi.h gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_psi_1_int(int n);+--+--   <http://www.google.com/search?q=gsl_sf_psi_1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_1_int :: Int -> Double+psi_1_int = gsl_sf_psi_1_int+foreign import ccall "psi.h gsl_sf_psi_1_int" gsl_sf_psi_1_int :: Int -> Double++-- | wrapper for int gsl_sf_psi_1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_psi_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_1_e :: Double -> (Double,Double)+psi_1_e x = createSFR "psi_1_e" $ gsl_sf_psi_1_e x+foreign import ccall "psi.h gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_psi_1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_psi_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_1 :: Double -> Double+psi_1 = gsl_sf_psi_1+foreign import ccall "psi.h gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double++-- | wrapper for int gsl_sf_psi_n_e(int n,double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_psi_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_n_e :: Int -> Double -> (Double,Double)+psi_n_e n x = createSFR "psi_n_e" $ gsl_sf_psi_n_e n x+foreign import ccall "psi.h gsl_sf_psi_n_e" gsl_sf_psi_n_e :: Int -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_psi_n(int n,double x);+--+--   <http://www.google.com/search?q=gsl_sf_psi_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+psi_n :: Int -> Double -> Double+psi_n = gsl_sf_psi_n+foreign import ccall "psi.h gsl_sf_psi_n" gsl_sf_psi_n :: Int -> Double -> Double
+ lib/Numeric/GSL/Special/Synchrotron.hs view
@@ -0,0 +1,53 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Synchrotron+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_synchrotron.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Synchrotron(+  synchrotron_1_e+, synchrotron_1+, synchrotron_2_e+, synchrotron_2+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_synchrotron_1_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_synchrotron_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+synchrotron_1_e :: Double -> (Double,Double)+synchrotron_1_e x = createSFR "synchrotron_1_e" $ gsl_sf_synchrotron_1_e x+foreign import ccall "synchrotron.h gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_synchrotron_1(double x);+--+--   <http://www.google.com/search?q=gsl_sf_synchrotron_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+synchrotron_1 :: Double -> Double+synchrotron_1 = gsl_sf_synchrotron_1+foreign import ccall "synchrotron.h gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double++-- | wrapper for int gsl_sf_synchrotron_2_e(double x,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_synchrotron_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+synchrotron_2_e :: Double -> (Double,Double)+synchrotron_2_e x = createSFR "synchrotron_2_e" $ gsl_sf_synchrotron_2_e x+foreign import ccall "synchrotron.h gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_synchrotron_2(double x);+--+--   <http://www.google.com/search?q=gsl_sf_synchrotron_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+synchrotron_2 :: Double -> Double+synchrotron_2 = gsl_sf_synchrotron_2+foreign import ccall "synchrotron.h gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double
+ lib/Numeric/GSL/Special/Trig.hs view
@@ -0,0 +1,164 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Trig+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.gnu.org/software/gsl/manual/html_node/Trigonometric-Functions.html>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Trig(+  sin_e+, Numeric.GSL.Special.Trig.sin+, cos_e+, Numeric.GSL.Special.Trig.cos+, hypot_e+, hypot+, sinc_e+, sinc+, lnsinh_e+, lnsinh+, lncosh_e+, lncosh+, sin_err_e+, cos_err_e+, angle_restrict_symm+, angle_restrict_pos+, angle_restrict_symm_err_e+, angle_restrict_pos_err_e+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_sin_e(double x,gsl_sf_result* result);+sin_e :: Double -> (Double,Double)+sin_e x = createSFR "sin_e" $ gsl_sf_sin_e x+foreign import ccall "trig.h gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_sin(double x);+sin :: Double -> Double+sin = gsl_sf_sin+foreign import ccall "trig.h gsl_sf_sin" gsl_sf_sin :: Double -> Double++-- | wrapper for int gsl_sf_cos_e(double x,gsl_sf_result* result);+cos_e :: Double -> (Double,Double)+cos_e x = createSFR "cos_e" $ gsl_sf_cos_e x+foreign import ccall "trig.h gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_cos(double x);+cos :: Double -> Double+cos = gsl_sf_cos+foreign import ccall "trig.h gsl_sf_cos" gsl_sf_cos :: Double -> Double++-- | wrapper for int gsl_sf_hypot_e(double x,double y,gsl_sf_result* result);+hypot_e :: Double -> Double -> (Double,Double)+hypot_e x y = createSFR "hypot_e" $ gsl_sf_hypot_e x y+foreign import ccall "trig.h gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hypot(double x,double y);+hypot :: Double -> Double -> Double+hypot = gsl_sf_hypot+foreign import ccall "trig.h gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double++-- | wrapper for int gsl_sf_complex_sin_e(double zr,double zi,gsl_sf_result* szr,gsl_sf_result* szi);+complex_sin_e :: Double -> Double -> Ptr Double -> (Double,Double)+complex_sin_e zr zi szr = createSFR "complex_sin_e" $ gsl_sf_complex_sin_e zr zi szr+foreign import ccall "trig.h gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_complex_cos_e(double zr,double zi,gsl_sf_result* czr,gsl_sf_result* czi);+complex_cos_e :: Double -> Double -> Ptr Double -> (Double,Double)+complex_cos_e zr zi czr = createSFR "complex_cos_e" $ gsl_sf_complex_cos_e zr zi czr+foreign import ccall "trig.h gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_complex_logsin_e(double zr,double zi,gsl_sf_result* lszr,gsl_sf_result* lszi);+complex_logsin_e :: Double -> Double -> Ptr Double -> (Double,Double)+complex_logsin_e zr zi lszr = createSFR "complex_logsin_e" $ gsl_sf_complex_logsin_e zr zi lszr+foreign import ccall "trig.h gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_sinc_e(double x,gsl_sf_result* result);+sinc_e :: Double -> (Double,Double)+sinc_e x = createSFR "sinc_e" $ gsl_sf_sinc_e x+foreign import ccall "trig.h gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_sinc(double x);+sinc :: Double -> Double+sinc = gsl_sf_sinc+foreign import ccall "trig.h gsl_sf_sinc" gsl_sf_sinc :: Double -> Double++-- | wrapper for int gsl_sf_lnsinh_e(double x,gsl_sf_result* result);+lnsinh_e :: Double -> (Double,Double)+lnsinh_e x = createSFR "lnsinh_e" $ gsl_sf_lnsinh_e x+foreign import ccall "trig.h gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lnsinh(double x);+lnsinh :: Double -> Double+lnsinh = gsl_sf_lnsinh+foreign import ccall "trig.h gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double++-- | wrapper for int gsl_sf_lncosh_e(double x,gsl_sf_result* result);+lncosh_e :: Double -> (Double,Double)+lncosh_e x = createSFR "lncosh_e" $ gsl_sf_lncosh_e x+foreign import ccall "trig.h gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_lncosh(double x);+lncosh :: Double -> Double+lncosh = gsl_sf_lncosh+foreign import ccall "trig.h gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double++-- | wrapper for int gsl_sf_polar_to_rect(double r,double theta,gsl_sf_result* x,gsl_sf_result* y);+polar_to_rect :: Double -> Double -> Ptr Double -> (Double,Double)+polar_to_rect r theta x = createSFR "polar_to_rect" $ gsl_sf_polar_to_rect r theta x+foreign import ccall "trig.h gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_rect_to_polar(double x,double y,gsl_sf_result* r,gsl_sf_result* theta);+rect_to_polar :: Double -> Double -> Ptr Double -> (Double,Double)+rect_to_polar x y r = createSFR "rect_to_polar" $ gsl_sf_rect_to_polar x y r+foreign import ccall "trig.h gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_sin_err_e(double x,double dx,gsl_sf_result* result);+sin_err_e :: Double -> Double -> (Double,Double)+sin_err_e x dx = createSFR "sin_err_e" $ gsl_sf_sin_err_e x dx+foreign import ccall "trig.h gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_cos_err_e(double x,double dx,gsl_sf_result* result);+cos_err_e :: Double -> Double -> (Double,Double)+cos_err_e x dx = createSFR "cos_err_e" $ gsl_sf_cos_err_e x dx+foreign import ccall "trig.h gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_angle_restrict_symm_e(double* theta);+angle_restrict_symm_e :: Ptr Double -> Int+angle_restrict_symm_e = gsl_sf_angle_restrict_symm_e+foreign import ccall "trig.h gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> Int++-- | wrapper for double gsl_sf_angle_restrict_symm(double theta);+angle_restrict_symm :: Double -> Double+angle_restrict_symm = gsl_sf_angle_restrict_symm+foreign import ccall "trig.h gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double++-- | wrapper for int gsl_sf_angle_restrict_pos_e(double* theta);+angle_restrict_pos_e :: Ptr Double -> Int+angle_restrict_pos_e = gsl_sf_angle_restrict_pos_e+foreign import ccall "trig.h gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> Int++-- | wrapper for double gsl_sf_angle_restrict_pos(double theta);+angle_restrict_pos :: Double -> Double+angle_restrict_pos = gsl_sf_angle_restrict_pos+foreign import ccall "trig.h gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double++-- | wrapper for int gsl_sf_angle_restrict_symm_err_e(double theta,gsl_sf_result* result);+angle_restrict_symm_err_e :: Double -> (Double,Double)+angle_restrict_symm_err_e theta = createSFR "angle_restrict_symm_err_e" $ gsl_sf_angle_restrict_symm_err_e theta+foreign import ccall "trig.h gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for int gsl_sf_angle_restrict_pos_err_e(double theta,gsl_sf_result* result);+angle_restrict_pos_err_e :: Double -> (Double,Double)+angle_restrict_pos_err_e theta = createSFR "angle_restrict_pos_err_e" $ gsl_sf_angle_restrict_pos_err_e theta+foreign import ccall "trig.h gsl_sf_angle_restrict_pos_err_e" gsl_sf_angle_restrict_pos_err_e :: Double -> Ptr Double -> IO(Int)
+ lib/Numeric/GSL/Special/Zeta.hs view
@@ -0,0 +1,133 @@+------------------------------------------------------------+{- |+Module      :  Numeric.GSL.Special.Zeta+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style+Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Wrappers for selected functions described at:++<http://www.google.com/search?q=gsl_sf_zeta.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>++-}+------------------------------------------------------------++module Numeric.GSL.Special.Zeta(+  zeta_int_e+, zeta_int+, zeta_e+, zeta+, zetam1_e+, zetam1+, zetam1_int_e+, zetam1_int+, hzeta_e+, hzeta+, eta_int_e+, eta_int+, eta_e+, eta+) where++import Foreign(Ptr)+import Numeric.GSL.Special.Internal++-- | wrapper for int gsl_sf_zeta_int_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_zeta_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zeta_int_e :: Int -> (Double,Double)+zeta_int_e n = createSFR "zeta_int_e" $ gsl_sf_zeta_int_e n+foreign import ccall "zeta.h gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_zeta_int(int n);+--+--   <http://www.google.com/search?q=gsl_sf_zeta_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zeta_int :: Int -> Double+zeta_int = gsl_sf_zeta_int+foreign import ccall "zeta.h gsl_sf_zeta_int" gsl_sf_zeta_int :: Int -> Double++-- | wrapper for int gsl_sf_zeta_e(double s,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_zeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zeta_e :: Double -> (Double,Double)+zeta_e s = createSFR "zeta_e" $ gsl_sf_zeta_e s+foreign import ccall "zeta.h gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_zeta(double s);+--+--   <http://www.google.com/search?q=gsl_sf_zeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zeta :: Double -> Double+zeta = gsl_sf_zeta+foreign import ccall "zeta.h gsl_sf_zeta" gsl_sf_zeta :: Double -> Double++-- | wrapper for int gsl_sf_zetam1_e(double s,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_zetam1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zetam1_e :: Double -> (Double,Double)+zetam1_e s = createSFR "zetam1_e" $ gsl_sf_zetam1_e s+foreign import ccall "zeta.h gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_zetam1(double s);+--+--   <http://www.google.com/search?q=gsl_sf_zetam1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zetam1 :: Double -> Double+zetam1 = gsl_sf_zetam1+foreign import ccall "zeta.h gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double++-- | wrapper for int gsl_sf_zetam1_int_e(int s,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_zetam1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zetam1_int_e :: Int -> (Double,Double)+zetam1_int_e s = createSFR "zetam1_int_e" $ gsl_sf_zetam1_int_e s+foreign import ccall "zeta.h gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_zetam1_int(int s);+--+--   <http://www.google.com/search?q=gsl_sf_zetam1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+zetam1_int :: Int -> Double+zetam1_int = gsl_sf_zetam1_int+foreign import ccall "zeta.h gsl_sf_zetam1_int" gsl_sf_zetam1_int :: Int -> Double++-- | wrapper for int gsl_sf_hzeta_e(double s,double q,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_hzeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hzeta_e :: Double -> Double -> (Double,Double)+hzeta_e s q = createSFR "hzeta_e" $ gsl_sf_hzeta_e s q+foreign import ccall "zeta.h gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_hzeta(double s,double q);+--+--   <http://www.google.com/search?q=gsl_sf_hzeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+hzeta :: Double -> Double -> Double+hzeta = gsl_sf_hzeta+foreign import ccall "zeta.h gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double++-- | wrapper for int gsl_sf_eta_int_e(int n,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_eta_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+eta_int_e :: Int -> (Double,Double)+eta_int_e n = createSFR "eta_int_e" $ gsl_sf_eta_int_e n+foreign import ccall "zeta.h gsl_sf_eta_int_e" gsl_sf_eta_int_e :: Int -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_eta_int(int n);+--+--   <http://www.google.com/search?q=gsl_sf_eta_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+eta_int :: Int -> Double+eta_int = gsl_sf_eta_int+foreign import ccall "zeta.h gsl_sf_eta_int" gsl_sf_eta_int :: Int -> Double++-- | wrapper for int gsl_sf_eta_e(double s,gsl_sf_result* result);+--+--   <http://www.google.com/search?q=gsl_sf_eta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+eta_e :: Double -> (Double,Double)+eta_e s = createSFR "eta_e" $ gsl_sf_eta_e s+foreign import ccall "zeta.h gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr Double -> IO(Int)++-- | wrapper for double gsl_sf_eta(double s);+--+--   <http://www.google.com/search?q=gsl_sf_eta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>+eta :: Double -> Double+eta = gsl_sf_eta+foreign import ccall "zeta.h gsl_sf_eta" gsl_sf_eta :: Double -> Double
+ lib/Numeric/GSL/Special/airy.h view
@@ -0,0 +1,24 @@+int gsl_sf_airy_Ai_e(double x,int mode,double* result);+double gsl_sf_airy_Ai(double x,int mode);+int gsl_sf_airy_Bi_e(double x,int mode,double* result);+double gsl_sf_airy_Bi(double x,int mode);+int gsl_sf_airy_Ai_scaled_e(double x,int mode,double* result);+double gsl_sf_airy_Ai_scaled(double x,int mode);+int gsl_sf_airy_Bi_scaled_e(double x,int mode,double* result);+double gsl_sf_airy_Bi_scaled(double x,int mode);+int gsl_sf_airy_Ai_deriv_e(double x,int mode,double* result);+double gsl_sf_airy_Ai_deriv(double x,int mode);+int gsl_sf_airy_Bi_deriv_e(double x,int mode,double* result);+double gsl_sf_airy_Bi_deriv(double x,int mode);+int gsl_sf_airy_Ai_deriv_scaled_e(double x,int mode,double* result);+double gsl_sf_airy_Ai_deriv_scaled(double x,int mode);+int gsl_sf_airy_Bi_deriv_scaled_e(double x,int mode,double* result);+double gsl_sf_airy_Bi_deriv_scaled(double x,int mode);+int gsl_sf_airy_zero_Ai_e(int s,double* result);+double gsl_sf_airy_zero_Ai(int s);+int gsl_sf_airy_zero_Bi_e(int s,double* result);+double gsl_sf_airy_zero_Bi(int s);+int gsl_sf_airy_zero_Ai_deriv_e(int s,double* result);+double gsl_sf_airy_zero_Ai_deriv(int s);+int gsl_sf_airy_zero_Bi_deriv_e(int s,double* result);+double gsl_sf_airy_zero_Bi_deriv(int s);
+ lib/Numeric/GSL/Special/auto.hs view
@@ -0,0 +1,233 @@+-- automatic generation of wrappers for simple GSL special functions++import Text.ParserCombinators.Parsec+import System+import Data.List(intersperse, isPrefixOf)+import Data.Char(toUpper,isUpper,toLower)++data Type = Normal Ident | Pointer Ident deriving (Eq, Show)++type Ident = String++data Header = Header Type Ident [(Type,Ident)] deriving Show++headers f = case parse parseHeaders "" f of+    Right l -> l+    Left s -> error (show s)+++rep (c,r) [] = []+rep (c,r) f@(x:xs) +  | c `isPrefixOf` f = r ++ rep (c,r) (drop (length c) f)+  | otherwise        = x:(rep (c,r) xs)+++fixlong [] = []+fixlong "\\" = []+fixlong ('\\':'\n':xs) = xs+fixlong (x:xs) = x : fixlong xs+++safe (Header _ _ args) =  all ok args +                         || all ok (init args) && kn (last args)+    where ok ((Normal s),_) | s `elem` ["double","float","int","gsl_mode_t"] = True+          ok _ = False+          kn ((Pointer "gsl_sf_result"),_) = True+          kn ((Pointer "gsl_sf_result_e10"),_) = True+          kn _ = False++++fixC s = rep ("gsl_mode_t","int") $ rep ("gsl_sf_result","double") $ rep ("gsl_sf_result_e10","double") $ s++main = do+    args <- getArgs+    let name = args!!0+        headerfile =+            case args of+                [n] -> "/usr/include/gsl/gsl_sf_"++n++".h"+                [_,f] -> f+    file <- readFile headerfile++    putStrLn headerfile+    --mapM_ print (headers $ fixlong file)+    let parsed = (headers $ fixlong file)+    writeFile (name ++".h") (fixC $ unlines $ map showC parsed) ++    --putStrLn ""+    --mapM (\(Header _ n _) -> putStrLn (drop 7 n ++",")) parsed+    --putStrLn ""+    --mapM_ (putStrLn.showFull (name ++".h")) parsed+    let exports = rep (")",") where") $ rep ("(\n","(\n  ") $ rep (",\n",", ") $ unlines $ ["("]++intersperse "," (map (\(Header _ n _) -> hName n) (filter safe parsed))++[")"]+    let defs = unlines $ map (showFull (name ++".h")) parsed+    let imports = "\nimport Foreign(Ptr)\nimport Numeric.GSL.Special.Internal\n"+    let mod = modhead name ++ "module Numeric.GSL.Special."++ upperFirst name++exports++imports++defs+    writeFile (upperFirst name ++ ".hs") mod+++google name = "<http://www.google.com/search?q="+               ++name+               ++"&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>"++modhead name = replicate 60 '-' ++ "\n"+             ++"{- |\n"+             ++"Module      :  Numeric.GSL.Special."++upperFirst name++"\n"+             ++"Copyright   :  (c) Alberto Ruiz 2006\n"+             ++"License     :  GPL-style\n"+             ++"Maintainer  :  Alberto Ruiz (aruiz at um dot es)\n"+             ++"Stability   :  provisional\n"+             ++"Portability :  uses ffi\n"+             ++"\nWrappers for selected functions described at:\n\n"+             ++ google ( "gsl_sf_"++name++".h")+             ++"\n\n-}\n"+             ++ replicate 60 '-' ++ "\n\n"++upperFirst (x:xs) = toUpper x : xs++comment = do+    string "/*"+    closecomment+    spaces+    return "comment"++closecomment = try (string "*/")+               <|> (do anyChar+                       closecomment)++ident = do +    spaces+    id <- many1 (noneOf "()[]* \n\t,;")+    spaces+    return id++comment' = between (char '(') (char ')') (many $ noneOf ")") +++define = do+    string "#"+    closedefine+    spaces+    return "define"++closedefine = try (string "\n")+              <|> (do anyChar+                      closedefine)++marks = do+    try (string "__BEGIN_DECLS" >> spaces >> return "begin")+    <|>+    try (string "__END_DECLS" >> spaces >> return "end")++++irrelevant =+    try comment+    <|>+    try define+    <|>+    marks+++parseHeaders = many parseHeader++parseHeader = do+    spaces+    many irrelevant+    spaces+    (res,name)  <- typ+    spaces+    args <- between (char '(') (char ')') (sepBy typ (char ','))+    spaces+    char ';'+    spaces+    many irrelevant+    return $ Header res name args++typ = try t1 <|> t2++symbol s = spaces >> string s >> spaces++t1 = do+    t <- try (symbol "const" >> symbol "unsigned" >> ident) -- aaagh +         <|>+         try (symbol "const" >> ident)+         <|>+         try (symbol "unsigned" >> ident)+         <|> ident+    n <- ident+    return (Normal t,n)++t2 = do+    t <- ident+    spaces+    char '*'+    spaces+    n <- ident+    return (Pointer t,n)++pure (Header _ _ args) | fst (last args) == Pointer "gsl_sf_result" = False+                       | fst (last args) == Pointer "gsl_sf_result_e10" = False+                       | otherwise = True++showC (Header t n args) = showCt t ++ " " ++ n ++ "("  ++ (concat $ intersperse "," $ map showCa args) ++ ");"++showCt (Normal s) = s+showCt (Pointer s) = s ++ "*"++showCa (t, a) = showCt t ++" "++ a++showH hc h@(Header t n args) = "foreign import ccall \""++hc++" "++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'+    where t' | pure h = showHt t+             | otherwise = "IO("++showHt t++")"++showHt (Normal (s:ss)) = toUpper s : ss+showHt (Pointer "gsl_sf_result") = "Ptr Double"+showHt (Pointer "gsl_sf_result_e10") = "Ptr ()"+showHt (Pointer (s:ss)) = "Ptr "++toUpper s : ss++showHa (t,a) = showHt t++showFull hc h@(Header t n args) = "\n-- | wrapper for "++showC h+                                ++"\n--\n--   "++google n ++"\n"+                                ++ boiler h ++"\n" +                                ++showH hc h ++fixmd1 = rep ("Gsl_mode_t","Precision")+fixmd2 = rep ("mode"," (precCode mode)")++boiler h@(Header t n args) | fst (last args) == Pointer "gsl_sf_result" = boilerResult h+                           | fst (last args) == Pointer "gsl_sf_result_e10" = boilerResultE10 h+                           | any isMode args = boilerMode h+                           | otherwise = boilerBasic h++isMode (Normal "gsl_mode_t",_) = True+isMode _ = False++hName n = f $ drop 7 n+    where f (s:ss) = toLower s : ss+++boilerResult h@(Header t n args) =+    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa (init args)) ++" -> " ++ "(Double,Double)\n" +++     hName n ++ " "++ initArgs args +++       " = createSFR \""++ hName n ++"\" $ " ++ n ++ " "++ (fixmd2 $ initArgs args)++boilerResultE10 h@(Header t n args) =+    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa (init args)) ++" -> " ++ "(Double,Int,Double)\n" +++     hName n ++ " "++ initArgs args +++       " = createSFR_E10 \""++ hName n ++"\" $ " ++ n ++ " "++ (fixmd2 $ initArgs args)++boilerBasic h@(Header t n args) = +    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$map showHa args) ++" -> " ++showHt t ++ "\n" +++      hName n ++ " = " ++fixmd2 n++boilerMode h@(Header t n args) =+    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa args) ++" -> " ++ showHt t++"\n" +++     hName n ++ " "++ allArgs args +++       " = " ++ n ++ " "++ (fixmd2 $ allArgs args)++cVar (v:vs) | isUpper v = toLower v : v : vs+            | otherwise = v:vs++allArgs args =  unwords (map (cVar.snd) args)+initArgs args = unwords (map (cVar.snd) (init args))
+ lib/Numeric/GSL/Special/autoall.sh view
@@ -0,0 +1,41 @@+#!/bin/bash++#Airy.hs+#  include Precision (..) in the export list+#Exp.hs+#  remove extern inline definition, qualify name+#Coupling+#  remove deprecated INCORRECT+#Trig.hs+#  qualify names+#Legendre.hs+#  remove extern inline+#Log.hs+#  remove extern inline, qualify name++#runhaskell auto airy+runhaskell auto bessel+runhaskell auto clausen+runhaskell auto coulomb+#runhaskell auto coupling+runhaskell auto dawson+runhaskell auto debye+runhaskell auto dilog+runhaskell auto elementary+runhaskell auto ellint+runhaskell auto erf+#runhaskell auto exp+runhaskell auto expint+runhaskell auto fermi_dirac+runhaskell auto gamma+runhaskell auto gegenbauer+runhaskell auto hyperg+runhaskell auto laguerre+runhaskell auto lambert+#runhaskell auto legendre+#runhaskell auto log+runhaskell auto pow_int+runhaskell auto psi+runhaskell auto synchrotron+#runhaskell auto trig+runhaskell auto zeta
+ lib/Numeric/GSL/Special/bessel.h view
@@ -0,0 +1,100 @@+int gsl_sf_bessel_J0_e(double x,double* result);+double gsl_sf_bessel_J0(double x);+int gsl_sf_bessel_J1_e(double x,double* result);+double gsl_sf_bessel_J1(double x);+int gsl_sf_bessel_Jn_e(int n,double x,double* result);+double gsl_sf_bessel_Jn(int n,double x);+int gsl_sf_bessel_Jn_array(int nmin,int nmax,double x,double* result_array);+int gsl_sf_bessel_Y0_e(double x,double* result);+double gsl_sf_bessel_Y0(double x);+int gsl_sf_bessel_Y1_e(double x,double* result);+double gsl_sf_bessel_Y1(double x);+int gsl_sf_bessel_Yn_e(int n,double x,double* result);+double gsl_sf_bessel_Yn(int n,double x);+int gsl_sf_bessel_Yn_array(int nmin,int nmax,double x,double* result_array);+int gsl_sf_bessel_I0_e(double x,double* result);+double gsl_sf_bessel_I0(double x);+int gsl_sf_bessel_I1_e(double x,double* result);+double gsl_sf_bessel_I1(double x);+int gsl_sf_bessel_In_e(int n,double x,double* result);+double gsl_sf_bessel_In(int n,double x);+int gsl_sf_bessel_In_array(int nmin,int nmax,double x,double* result_array);+int gsl_sf_bessel_I0_scaled_e(double x,double* result);+double gsl_sf_bessel_I0_scaled(double x);+int gsl_sf_bessel_I1_scaled_e(double x,double* result);+double gsl_sf_bessel_I1_scaled(double x);+int gsl_sf_bessel_In_scaled_e(int n,double x,double* result);+double gsl_sf_bessel_In_scaled(int n,double x);+int gsl_sf_bessel_In_scaled_array(int nmin,int nmax,double x,double* result_array);+int gsl_sf_bessel_K0_e(double x,double* result);+double gsl_sf_bessel_K0(double x);+int gsl_sf_bessel_K1_e(double x,double* result);+double gsl_sf_bessel_K1(double x);+int gsl_sf_bessel_Kn_e(int n,double x,double* result);+double gsl_sf_bessel_Kn(int n,double x);+int gsl_sf_bessel_Kn_array(int nmin,int nmax,double x,double* result_array);+int gsl_sf_bessel_K0_scaled_e(double x,double* result);+double gsl_sf_bessel_K0_scaled(double x);+int gsl_sf_bessel_K1_scaled_e(double x,double* result);+double gsl_sf_bessel_K1_scaled(double x);+int gsl_sf_bessel_Kn_scaled_e(int n,double x,double* result);+double gsl_sf_bessel_Kn_scaled(int n,double x);+int gsl_sf_bessel_Kn_scaled_array(int nmin,int nmax,double x,double* result_array);+int gsl_sf_bessel_j0_e(double x,double* result);+double gsl_sf_bessel_j0(double x);+int gsl_sf_bessel_j1_e(double x,double* result);+double gsl_sf_bessel_j1(double x);+int gsl_sf_bessel_j2_e(double x,double* result);+double gsl_sf_bessel_j2(double x);+int gsl_sf_bessel_jl_e(int l,double x,double* result);+double gsl_sf_bessel_jl(int l,double x);+int gsl_sf_bessel_jl_array(int lmax,double x,double* result_array);+int gsl_sf_bessel_jl_steed_array(int lmax,double x,double* jl_x_array);+int gsl_sf_bessel_y0_e(double x,double* result);+double gsl_sf_bessel_y0(double x);+int gsl_sf_bessel_y1_e(double x,double* result);+double gsl_sf_bessel_y1(double x);+int gsl_sf_bessel_y2_e(double x,double* result);+double gsl_sf_bessel_y2(double x);+int gsl_sf_bessel_yl_e(int l,double x,double* result);+double gsl_sf_bessel_yl(int l,double x);+int gsl_sf_bessel_yl_array(int lmax,double x,double* result_array);+int gsl_sf_bessel_i0_scaled_e(double x,double* result);+double gsl_sf_bessel_i0_scaled(double x);+int gsl_sf_bessel_i1_scaled_e(double x,double* result);+double gsl_sf_bessel_i1_scaled(double x);+int gsl_sf_bessel_i2_scaled_e(double x,double* result);+double gsl_sf_bessel_i2_scaled(double x);+int gsl_sf_bessel_il_scaled_e(int l,double x,double* result);+double gsl_sf_bessel_il_scaled(int l,double x);+int gsl_sf_bessel_il_scaled_array(int lmax,double x,double* result_array);+int gsl_sf_bessel_k0_scaled_e(double x,double* result);+double gsl_sf_bessel_k0_scaled(double x);+int gsl_sf_bessel_k1_scaled_e(double x,double* result);+double gsl_sf_bessel_k1_scaled(double x);+int gsl_sf_bessel_k2_scaled_e(double x,double* result);+double gsl_sf_bessel_k2_scaled(double x);+int gsl_sf_bessel_kl_scaled_e(int l,double x,double* result);+double gsl_sf_bessel_kl_scaled(int l,double x);+int gsl_sf_bessel_kl_scaled_array(int lmax,double x,double* result_array);+int gsl_sf_bessel_Jnu_e(double nu,double x,double* result);+double gsl_sf_bessel_Jnu(double nu,double x);+int gsl_sf_bessel_Ynu_e(double nu,double x,double* result);+double gsl_sf_bessel_Ynu(double nu,double x);+int gsl_sf_bessel_sequence_Jnu_e(double nu,int mode,size_t size,double* v);+int gsl_sf_bessel_Inu_scaled_e(double nu,double x,double* result);+double gsl_sf_bessel_Inu_scaled(double nu,double x);+int gsl_sf_bessel_Inu_e(double nu,double x,double* result);+double gsl_sf_bessel_Inu(double nu,double x);+int gsl_sf_bessel_Knu_scaled_e(double nu,double x,double* result);+double gsl_sf_bessel_Knu_scaled(double nu,double x);+int gsl_sf_bessel_Knu_e(double nu,double x,double* result);+double gsl_sf_bessel_Knu(double nu,double x);+int gsl_sf_bessel_lnKnu_e(double nu,double x,double* result);+double gsl_sf_bessel_lnKnu(double nu,double x);+int gsl_sf_bessel_zero_J0_e(int s,double* result);+double gsl_sf_bessel_zero_J0(int s);+int gsl_sf_bessel_zero_J1_e(int s,double* result);+double gsl_sf_bessel_zero_J1(int s);+int gsl_sf_bessel_zero_Jnu_e(double nu,int s,double* result);+double gsl_sf_bessel_zero_Jnu(double nu,int s);
+ lib/Numeric/GSL/Special/clausen.h view
@@ -0,0 +1,2 @@+int gsl_sf_clausen_e(double x,double* result);+double gsl_sf_clausen(double x);
+ lib/Numeric/GSL/Special/coulomb.h view
@@ -0,0 +1,11 @@+int gsl_sf_hydrogenicR_1_e(double Z,double r,double* result);+double gsl_sf_hydrogenicR_1(double Z,double r);+int gsl_sf_hydrogenicR_e(int n,int l,double Z,double r,double* result);+double gsl_sf_hydrogenicR(int n,int l,double Z,double r);+int gsl_sf_coulomb_wave_FG_e(double eta,double x,double lam_F,int k_lam_G,double* F,double* Fp,double* G,double* Gp,double* exp_F,double* exp_G);+int gsl_sf_coulomb_wave_F_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);+int gsl_sf_coulomb_wave_FG_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* gc_array,double* F_exponent,double* G_exponent);+int gsl_sf_coulomb_wave_FGp_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* fcp_array,double* gc_array,double* gcp_array,double* F_exponent,double* G_exponent);+int gsl_sf_coulomb_wave_sphF_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);+int gsl_sf_coulomb_CL_e(double L,double eta,double* result);+int gsl_sf_coulomb_CL_array(double Lmin,int kmax,double eta,double* cl);
+ lib/Numeric/GSL/Special/coupling.h view
@@ -0,0 +1,10 @@+int gsl_sf_coupling_3j_e(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc,double* result);+double gsl_sf_coupling_3j(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc);+int gsl_sf_coupling_6j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);+double gsl_sf_coupling_6j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);+int gsl_sf_coupling_RacahW_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);+double gsl_sf_coupling_RacahW(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);+int gsl_sf_coupling_9j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji,double* result);+double gsl_sf_coupling_9j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji);+int gsl_sf_coupling_6j_INCORRECT_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);+double gsl_sf_coupling_6j_INCORRECT(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
+ lib/Numeric/GSL/Special/dawson.h view
@@ -0,0 +1,2 @@+int gsl_sf_dawson_e(double x,double* result);+double gsl_sf_dawson(double x);
+ lib/Numeric/GSL/Special/debye.h view
@@ -0,0 +1,8 @@+int gsl_sf_debye_1_e(double x,double* result);+double gsl_sf_debye_1(double x);+int gsl_sf_debye_2_e(double x,double* result);+double gsl_sf_debye_2(double x);+int gsl_sf_debye_3_e(double x,double* result);+double gsl_sf_debye_3(double x);+int gsl_sf_debye_4_e(double x,double* result);+double gsl_sf_debye_4(double x);
+ lib/Numeric/GSL/Special/dilog.h view
@@ -0,0 +1,5 @@+int gsl_sf_dilog_e(double x,double* result);+double gsl_sf_dilog(double x);+int gsl_sf_complex_dilog_xy_e(double x,double y,double* result_re,double* result_im);+int gsl_sf_complex_dilog_e(double r,double theta,double* result_re,double* result_im);+int gsl_sf_complex_spence_xy_e(double x,double y,double* real_sp,double* imag_sp);
+ lib/Numeric/GSL/Special/elementary.h view
@@ -0,0 +1,3 @@+int gsl_sf_multiply_e(double x,double y,double* result);+double gsl_sf_multiply(double x,double y);+int gsl_sf_multiply_err_e(double x,double dx,double y,double dy,double* result);
+ lib/Numeric/GSL/Special/ellint.h view
@@ -0,0 +1,20 @@+int gsl_sf_ellint_Kcomp_e(double k,int mode,double* result);+double gsl_sf_ellint_Kcomp(double k,int mode);+int gsl_sf_ellint_Ecomp_e(double k,int mode,double* result);+double gsl_sf_ellint_Ecomp(double k,int mode);+int gsl_sf_ellint_F_e(double phi,double k,int mode,double* result);+double gsl_sf_ellint_F(double phi,double k,int mode);+int gsl_sf_ellint_E_e(double phi,double k,int mode,double* result);+double gsl_sf_ellint_E(double phi,double k,int mode);+int gsl_sf_ellint_P_e(double phi,double k,double n,int mode,double* result);+double gsl_sf_ellint_P(double phi,double k,double n,int mode);+int gsl_sf_ellint_D_e(double phi,double k,double n,int mode,double* result);+double gsl_sf_ellint_D(double phi,double k,double n,int mode);+int gsl_sf_ellint_RC_e(double x,double y,int mode,double* result);+double gsl_sf_ellint_RC(double x,double y,int mode);+int gsl_sf_ellint_RD_e(double x,double y,double z,int mode,double* result);+double gsl_sf_ellint_RD(double x,double y,double z,int mode);+int gsl_sf_ellint_RF_e(double x,double y,double z,int mode,double* result);+double gsl_sf_ellint_RF(double x,double y,double z,int mode);+int gsl_sf_ellint_RJ_e(double x,double y,double z,double p,int mode,double* result);+double gsl_sf_ellint_RJ(double x,double y,double z,double p,int mode);
+ lib/Numeric/GSL/Special/erf.h view
@@ -0,0 +1,12 @@+int gsl_sf_erfc_e(double x,double* result);+double gsl_sf_erfc(double x);+int gsl_sf_log_erfc_e(double x,double* result);+double gsl_sf_log_erfc(double x);+int gsl_sf_erf_e(double x,double* result);+double gsl_sf_erf(double x);+int gsl_sf_erf_Z_e(double x,double* result);+int gsl_sf_erf_Q_e(double x,double* result);+double gsl_sf_erf_Z(double x);+double gsl_sf_erf_Q(double x);+int gsl_sf_hazard_e(double x,double* result);+double gsl_sf_hazard(double x);
+ lib/Numeric/GSL/Special/exp.h view
@@ -0,0 +1,18 @@+int gsl_sf_exp_e(double x,double* result);+double gsl_sf_exp(double x);+int gsl_sf_exp_e10_e(double x,double* result);+int gsl_sf_exp_mult_e(double x,double y,double* result);+double gsl_sf_exp_mult(double x,double y);+int gsl_sf_exp_mult_e10_e(double x,double y,double* result);+int gsl_sf_expm1_e(double x,double* result);+double gsl_sf_expm1(double x);+int gsl_sf_exprel_e(double x,double* result);+double gsl_sf_exprel(double x);+int gsl_sf_exprel_2_e(double x,double* result);+double gsl_sf_exprel_2(double x);+int gsl_sf_exprel_n_e(int n,double x,double* result);+double gsl_sf_exprel_n(int n,double x);+int gsl_sf_exp_err_e(double x,double dx,double* result);+int gsl_sf_exp_err_e10_e(double x,double dx,double* result);+int gsl_sf_exp_mult_err_e(double x,double dx,double y,double dy,double* result);+int gsl_sf_exp_mult_err_e10_e(double x,double dx,double y,double dy,double* result);
+ lib/Numeric/GSL/Special/expint.h view
@@ -0,0 +1,24 @@+int gsl_sf_expint_E1_e(double x,double* result);+double gsl_sf_expint_E1(double x);+int gsl_sf_expint_E2_e(double x,double* result);+double gsl_sf_expint_E2(double x);+int gsl_sf_expint_E1_scaled_e(double x,double* result);+double gsl_sf_expint_E1_scaled(double x);+int gsl_sf_expint_E2_scaled_e(double x,double* result);+double gsl_sf_expint_E2_scaled(double x);+int gsl_sf_expint_Ei_e(double x,double* result);+double gsl_sf_expint_Ei(double x);+int gsl_sf_expint_Ei_scaled_e(double x,double* result);+double gsl_sf_expint_Ei_scaled(double x);+int gsl_sf_Shi_e(double x,double* result);+double gsl_sf_Shi(double x);+int gsl_sf_Chi_e(double x,double* result);+double gsl_sf_Chi(double x);+int gsl_sf_expint_3_e(double x,double* result);+double gsl_sf_expint_3(double x);+int gsl_sf_Si_e(double x,double* result);+double gsl_sf_Si(double x);+int gsl_sf_Ci_e(double x,double* result);+double gsl_sf_Ci(double x);+int gsl_sf_atanint_e(double x,double* result);+double gsl_sf_atanint(double x);
+ lib/Numeric/GSL/Special/fermi_dirac.h view
@@ -0,0 +1,18 @@+int gsl_sf_fermi_dirac_m1_e(double x,double* result);+double gsl_sf_fermi_dirac_m1(double x);+int gsl_sf_fermi_dirac_0_e(double x,double* result);+double gsl_sf_fermi_dirac_0(double x);+int gsl_sf_fermi_dirac_1_e(double x,double* result);+double gsl_sf_fermi_dirac_1(double x);+int gsl_sf_fermi_dirac_2_e(double x,double* result);+double gsl_sf_fermi_dirac_2(double x);+int gsl_sf_fermi_dirac_int_e(int j,double x,double* result);+double gsl_sf_fermi_dirac_int(int j,double x);+int gsl_sf_fermi_dirac_mhalf_e(double x,double* result);+double gsl_sf_fermi_dirac_mhalf(double x);+int gsl_sf_fermi_dirac_half_e(double x,double* result);+double gsl_sf_fermi_dirac_half(double x);+int gsl_sf_fermi_dirac_3half_e(double x,double* result);+double gsl_sf_fermi_dirac_3half(double x);+int gsl_sf_fermi_dirac_inc_0_e(double x,double b,double* result);+double gsl_sf_fermi_dirac_inc_0(double x,double b);
+ lib/Numeric/GSL/Special/gamma.h view
@@ -0,0 +1,43 @@+int gsl_sf_lngamma_e(double x,double* result);+double gsl_sf_lngamma(double x);+int gsl_sf_lngamma_sgn_e(double x,double* result_lg,double* sgn);+int gsl_sf_gamma_e(double x,double* result);+double gsl_sf_gamma(double x);+int gsl_sf_gammastar_e(double x,double* result);+double gsl_sf_gammastar(double x);+int gsl_sf_gammainv_e(double x,double* result);+double gsl_sf_gammainv(double x);+int gsl_sf_lngamma_complex_e(double zr,double zi,double* lnr,double* arg);+int gsl_sf_taylorcoeff_e(int n,double x,double* result);+double gsl_sf_taylorcoeff(int n,double x);+int gsl_sf_fact_e(int n,double* result);+double gsl_sf_fact(int n);+int gsl_sf_doublefact_e(int n,double* result);+double gsl_sf_doublefact(int n);+int gsl_sf_lnfact_e(int n,double* result);+double gsl_sf_lnfact(int n);+int gsl_sf_lndoublefact_e(int n,double* result);+double gsl_sf_lndoublefact(int n);+int gsl_sf_lnchoose_e(int n,int m,double* result);+double gsl_sf_lnchoose(int n,int m);+int gsl_sf_choose_e(int n,int m,double* result);+double gsl_sf_choose(int n,int m);+int gsl_sf_lnpoch_e(double a,double x,double* result);+double gsl_sf_lnpoch(double a,double x);+int gsl_sf_lnpoch_sgn_e(double a,double x,double* result,double* sgn);+int gsl_sf_poch_e(double a,double x,double* result);+double gsl_sf_poch(double a,double x);+int gsl_sf_pochrel_e(double a,double x,double* result);+double gsl_sf_pochrel(double a,double x);+int gsl_sf_gamma_inc_Q_e(double a,double x,double* result);+double gsl_sf_gamma_inc_Q(double a,double x);+int gsl_sf_gamma_inc_P_e(double a,double x,double* result);+double gsl_sf_gamma_inc_P(double a,double x);+int gsl_sf_gamma_inc_e(double a,double x,double* result);+double gsl_sf_gamma_inc(double a,double x);+int gsl_sf_lnbeta_e(double a,double b,double* result);+double gsl_sf_lnbeta(double a,double b);+int gsl_sf_beta_e(double a,double b,double* result);+double gsl_sf_beta(double a,double b);+int gsl_sf_beta_inc_e(double a,double b,double x,double* result);+double gsl_sf_beta_inc(double a,double b,double x);
+ lib/Numeric/GSL/Special/gegenbauer.h view
@@ -0,0 +1,9 @@+int gsl_sf_gegenpoly_1_e(double lambda,double x,double* result);+int gsl_sf_gegenpoly_2_e(double lambda,double x,double* result);+int gsl_sf_gegenpoly_3_e(double lambda,double x,double* result);+double gsl_sf_gegenpoly_1(double lambda,double x);+double gsl_sf_gegenpoly_2(double lambda,double x);+double gsl_sf_gegenpoly_3(double lambda,double x);+int gsl_sf_gegenpoly_n_e(int n,double lambda,double x,double* result);+double gsl_sf_gegenpoly_n(int n,double lambda,double x);+int gsl_sf_gegenpoly_array(int nmax,double lambda,double x,double* result_array);
+ lib/Numeric/GSL/Special/gsl_sf_exp.h view
@@ -0,0 +1,146 @@+/* specfunc/gsl_sf_exp.h+ * + * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman+ * + * This program is free software; you can redistribute it and/or modify+ * it under the terms of the GNU General Public License as published by+ * the Free Software Foundation; either version 2 of the License, or (at+ * your option) any later version.+ * + * This program is distributed in the hope that it will be useful, but+ * WITHOUT ANY WARRANTY; without even the implied warranty of+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU+ * General Public License for more details.+ * + * You should have received a copy of the GNU General Public License+ * along with this program; if not, write to the Free Software+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.+ */++/* Author:  G. Jungman */++#ifndef __GSL_SF_EXP_H__+#define __GSL_SF_EXP_H__++#include <gsl/gsl_sf_result.h>+#include <gsl/gsl_precision.h>++#undef __BEGIN_DECLS+#undef __END_DECLS+#ifdef __cplusplus+# define __BEGIN_DECLS extern "C" {+# define __END_DECLS }+#else+# define __BEGIN_DECLS /* empty */+# define __END_DECLS /* empty */+#endif++__BEGIN_DECLS++/* Provide an exp() function with GSL semantics,+ * i.e. with proper error checking, etc.+ *+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW+ */+int gsl_sf_exp_e(const double x, gsl_sf_result * result);+double gsl_sf_exp(const double x);+++/* Exp(x)+ *+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW+ */+int gsl_sf_exp_e10_e(const double x, gsl_sf_result_e10 * result);+++/* Exponentiate and multiply by a given factor:  y * Exp(x)+ *+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW+ */+int gsl_sf_exp_mult_e(const double x, const double y, gsl_sf_result * result);+double gsl_sf_exp_mult(const double x, const double y);+++/* Exponentiate and multiply by a given factor:  y * Exp(x)+ *+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW+ */+int gsl_sf_exp_mult_e10_e(const double x, const double y, gsl_sf_result_e10 * result);+++/* exp(x)-1+ *+ * exceptions: GSL_EOVRFLW+ */+int gsl_sf_expm1_e(const double x, gsl_sf_result * result);+double gsl_sf_expm1(const double x);+++/* (exp(x)-1)/x = 1 + x/2 + x^2/(2*3) + x^3/(2*3*4) + ...+ *+ * exceptions: GSL_EOVRFLW+ */+int gsl_sf_exprel_e(const double x, gsl_sf_result * result);+double gsl_sf_exprel(const double x);+++/* 2(exp(x)-1-x)/x^2 = 1 + x/3 + x^2/(3*4) + x^3/(3*4*5) + ...+ *+ * exceptions: GSL_EOVRFLW+ */+int gsl_sf_exprel_2_e(double x, gsl_sf_result * result);+double gsl_sf_exprel_2(const double x);+++/* Similarly for the N-th generalization of+ * the above. The so-called N-relative exponential+ *+ * exprel_N(x) = N!/x^N (exp(x) - Sum[x^k/k!, {k,0,N-1}])+ *             = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ...+ *             = 1F1(1,1+N,x)+ */+int gsl_sf_exprel_n_e(const int n, const double x, gsl_sf_result * result);+double gsl_sf_exprel_n(const int n, const double x);+++/* Exponentiate a quantity with an associated error.+ */+int gsl_sf_exp_err_e(const double x, const double dx, gsl_sf_result * result);++/* Exponentiate a quantity with an associated error.+ */+int gsl_sf_exp_err_e10_e(const double x, const double dx, gsl_sf_result_e10 * result);+++/* Exponentiate and multiply by a given factor:  y * Exp(x),+ * for quantities with associated errors.+ *+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW+ */+int gsl_sf_exp_mult_err_e(const double x, const double dx, const double y, const double dy, gsl_sf_result * result);+++/* Exponentiate and multiply by a given factor:  y * Exp(x),+ * for quantities with associated errors.+ *+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW+ */+int gsl_sf_exp_mult_err_e10_e(const double x, const double dx, const double y, const double dy, gsl_sf_result_e10 * result);++__END_DECLS+++#ifdef HAVE_INLINE+#include <gsl/gsl_math.h>+#include <gsl/gsl_errno.h>++__BEGIN_DECLS++++__END_DECLS++#endif /* HAVE_INLINE */+++#endif /* __GSL_SF_EXP_H__ */
+ lib/Numeric/GSL/Special/gsl_sf_log.h view
@@ -0,0 +1,90 @@+/* specfunc/gsl_sf_log.h+ * + * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman+ * + * This program is free software; you can redistribute it and/or modify+ * it under the terms of the GNU General Public License as published by+ * the Free Software Foundation; either version 2 of the License, or (at+ * your option) any later version.+ * + * This program is distributed in the hope that it will be useful, but+ * WITHOUT ANY WARRANTY; without even the implied warranty of+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU+ * General Public License for more details.+ * + * You should have received a copy of the GNU General Public License+ * along with this program; if not, write to the Free Software+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.+ */++/* Author:  G. Jungman */++#ifndef __GSL_SF_LOG_H__+#define __GSL_SF_LOG_H__++#include <gsl/gsl_sf_result.h>++#undef __BEGIN_DECLS+#undef __END_DECLS+#ifdef __cplusplus+# define __BEGIN_DECLS extern "C" {+# define __END_DECLS }+#else+# define __BEGIN_DECLS /* empty */+# define __END_DECLS /* empty */+#endif++__BEGIN_DECLS+++/* Provide a logarithm function with GSL semantics.+ *+ * exceptions: GSL_EDOM+ */+int gsl_sf_log_e(const double x, gsl_sf_result * result);+double gsl_sf_log(const double x);+++/* Log(|x|)+ *+ * exceptions: GSL_EDOM+ */+int gsl_sf_log_abs_e(const double x, gsl_sf_result * result);+double gsl_sf_log_abs(const double x);+++/* Complex Logarithm+ *   exp(lnr + I theta) = zr + I zi+ * Returns argument in [-pi,pi].+ *+ * exceptions: GSL_EDOM+ */+int gsl_sf_complex_log_e(const double zr, const double zi, gsl_sf_result * lnr, gsl_sf_result * theta);+++/* Log(1 + x)+ *+ * exceptions: GSL_EDOM+ */+int gsl_sf_log_1plusx_e(const double x, gsl_sf_result * result);+double gsl_sf_log_1plusx(const double x);+++/* Log(1 + x) - x+ *+ * exceptions: GSL_EDOM+ */+int gsl_sf_log_1plusx_mx_e(const double x, gsl_sf_result * result);+double gsl_sf_log_1plusx_mx(const double x);+++#ifdef HAVE_INLINE+#include <gsl/gsl_math.h>+#include <gsl/gsl_errno.h>++#endif /* HAVE_INLINE */+++__END_DECLS++#endif /* __GSL_SF_LOG_H__ */
+ lib/Numeric/GSL/Special/hyperg.h view
@@ -0,0 +1,22 @@+int gsl_sf_hyperg_0F1_e(double c,double x,double* result);+double gsl_sf_hyperg_0F1(double c,double x);+int gsl_sf_hyperg_1F1_int_e(int m,int n,double x,double* result);+double gsl_sf_hyperg_1F1_int(int m,int n,double x);+int gsl_sf_hyperg_1F1_e(double a,double b,double x,double* result);+double gsl_sf_hyperg_1F1(double a,double b,double x);+int gsl_sf_hyperg_U_int_e(int m,int n,double x,double* result);+double gsl_sf_hyperg_U_int(int m,int n,double x);+int gsl_sf_hyperg_U_int_e10_e(int m,int n,double x,double* result);+int gsl_sf_hyperg_U_e(double a,double b,double x,double* result);+double gsl_sf_hyperg_U(double a,double b,double x);+int gsl_sf_hyperg_U_e10_e(double a,double b,double x,double* result);+int gsl_sf_hyperg_2F1_e(double a,double b,double c,double x,double* result);+double gsl_sf_hyperg_2F1(double a,double b,double c,double x);+int gsl_sf_hyperg_2F1_conj_e(double aR,double aI,double c,double x,double* result);+double gsl_sf_hyperg_2F1_conj(double aR,double aI,double c,double x);+int gsl_sf_hyperg_2F1_renorm_e(double a,double b,double c,double x,double* result);+double gsl_sf_hyperg_2F1_renorm(double a,double b,double c,double x);+int gsl_sf_hyperg_2F1_conj_renorm_e(double aR,double aI,double c,double x,double* result);+double gsl_sf_hyperg_2F1_conj_renorm(double aR,double aI,double c,double x);+int gsl_sf_hyperg_2F0_e(double a,double b,double x,double* result);+double gsl_sf_hyperg_2F0(double a,double b,double x);
+ lib/Numeric/GSL/Special/laguerre.h view
@@ -0,0 +1,8 @@+int gsl_sf_laguerre_1_e(double a,double x,double* result);+int gsl_sf_laguerre_2_e(double a,double x,double* result);+int gsl_sf_laguerre_3_e(double a,double x,double* result);+double gsl_sf_laguerre_1(double a,double x);+double gsl_sf_laguerre_2(double a,double x);+double gsl_sf_laguerre_3(double a,double x);+int gsl_sf_laguerre_n_e(int n,double a,double x,double* result);+double gsl_sf_laguerre_n(int n,double a,double x);
+ lib/Numeric/GSL/Special/lambert.h view
@@ -0,0 +1,4 @@+int gsl_sf_lambert_W0_e(double x,double* result);+double gsl_sf_lambert_W0(double x);+int gsl_sf_lambert_Wm1_e(double x,double* result);+double gsl_sf_lambert_Wm1(double x);
+ lib/Numeric/GSL/Special/legendre.h view
@@ -0,0 +1,44 @@+int gsl_sf_legendre_Pl_e(int l,double x,double* result);+double gsl_sf_legendre_Pl(int l,double x);+int gsl_sf_legendre_Pl_array(int lmax,double x,double* result_array);+int gsl_sf_legendre_Pl_deriv_array(int lmax,double x,double* result_array,double* result_deriv_array);+int gsl_sf_legendre_P1_e(double x,double* result);+int gsl_sf_legendre_P2_e(double x,double* result);+int gsl_sf_legendre_P3_e(double x,double* result);+double gsl_sf_legendre_P1(double x);+double gsl_sf_legendre_P2(double x);+double gsl_sf_legendre_P3(double x);+int gsl_sf_legendre_Q0_e(double x,double* result);+double gsl_sf_legendre_Q0(double x);+int gsl_sf_legendre_Q1_e(double x,double* result);+double gsl_sf_legendre_Q1(double x);+int gsl_sf_legendre_Ql_e(int l,double x,double* result);+double gsl_sf_legendre_Ql(int l,double x);+int gsl_sf_legendre_Plm_e(int l,int m,double x,double* result);+double gsl_sf_legendre_Plm(int l,int m,double x);+int gsl_sf_legendre_Plm_array(int lmax,int m,double x,double* result_array);+int gsl_sf_legendre_Plm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);+int gsl_sf_legendre_sphPlm_e(int l,int m,double x,double* result);+double gsl_sf_legendre_sphPlm(int l,int m,double x);+int gsl_sf_legendre_sphPlm_array(int lmax,int m,double x,double* result_array);+int gsl_sf_legendre_sphPlm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);+int gsl_sf_legendre_array_size(int lmax,int m);+int gsl_sf_conicalP_half_e(double lambda,double x,double* result);+double gsl_sf_conicalP_half(double lambda,double x);+int gsl_sf_conicalP_mhalf_e(double lambda,double x,double* result);+double gsl_sf_conicalP_mhalf(double lambda,double x);+int gsl_sf_conicalP_0_e(double lambda,double x,double* result);+double gsl_sf_conicalP_0(double lambda,double x);+int gsl_sf_conicalP_1_e(double lambda,double x,double* result);+double gsl_sf_conicalP_1(double lambda,double x);+int gsl_sf_conicalP_sph_reg_e(int l,double lambda,double x,double* result);+double gsl_sf_conicalP_sph_reg(int l,double lambda,double x);+int gsl_sf_conicalP_cyl_reg_e(int m,double lambda,double x,double* result);+double gsl_sf_conicalP_cyl_reg(int m,double lambda,double x);+int gsl_sf_legendre_H3d_0_e(double lambda,double eta,double* result);+double gsl_sf_legendre_H3d_0(double lambda,double eta);+int gsl_sf_legendre_H3d_1_e(double lambda,double eta,double* result);+double gsl_sf_legendre_H3d_1(double lambda,double eta);+int gsl_sf_legendre_H3d_e(int l,double lambda,double eta,double* result);+double gsl_sf_legendre_H3d(int l,double lambda,double eta);+int gsl_sf_legendre_H3d_array(int lmax,double lambda,double eta,double* result_array);
+ lib/Numeric/GSL/Special/log.h view
@@ -0,0 +1,9 @@+int gsl_sf_log_e(double x,double* result);+double gsl_sf_log(double x);+int gsl_sf_log_abs_e(double x,double* result);+double gsl_sf_log_abs(double x);+int gsl_sf_complex_log_e(double zr,double zi,double* lnr,double* theta);+int gsl_sf_log_1plusx_e(double x,double* result);+double gsl_sf_log_1plusx(double x);+int gsl_sf_log_1plusx_mx_e(double x,double* result);+double gsl_sf_log_1plusx_mx(double x);
+ lib/Numeric/GSL/Special/pow_int.h view
@@ -0,0 +1,2 @@+int gsl_sf_pow_int_e(double x,int n,double* result);+double gsl_sf_pow_int(double x,int n);
+ lib/Numeric/GSL/Special/psi.h view
@@ -0,0 +1,12 @@+int gsl_sf_psi_int_e(int n,double* result);+double gsl_sf_psi_int(int n);+int gsl_sf_psi_e(double x,double* result);+double gsl_sf_psi(double x);+int gsl_sf_psi_1piy_e(double y,double* result);+double gsl_sf_psi_1piy(double y);+int gsl_sf_psi_1_int_e(int n,double* result);+double gsl_sf_psi_1_int(int n);+int gsl_sf_psi_1_e(double x,double* result);+double gsl_sf_psi_1(double x);+int gsl_sf_psi_n_e(int n,double x,double* result);+double gsl_sf_psi_n(int n,double x);
+ lib/Numeric/GSL/Special/synchrotron.h view
@@ -0,0 +1,4 @@+int gsl_sf_synchrotron_1_e(double x,double* result);+double gsl_sf_synchrotron_1(double x);+int gsl_sf_synchrotron_2_e(double x,double* result);+double gsl_sf_synchrotron_2(double x);
+ lib/Numeric/GSL/Special/trig.h view
@@ -0,0 +1,25 @@+int gsl_sf_sin_e(double x,double* result);+double gsl_sf_sin(double x);+int gsl_sf_cos_e(double x,double* result);+double gsl_sf_cos(double x);+int gsl_sf_hypot_e(double x,double y,double* result);+double gsl_sf_hypot(double x,double y);+int gsl_sf_complex_sin_e(double zr,double zi,double* szr,double* szi);+int gsl_sf_complex_cos_e(double zr,double zi,double* czr,double* czi);+int gsl_sf_complex_logsin_e(double zr,double zi,double* lszr,double* lszi);+int gsl_sf_sinc_e(double x,double* result);+double gsl_sf_sinc(double x);+int gsl_sf_lnsinh_e(double x,double* result);+double gsl_sf_lnsinh(double x);+int gsl_sf_lncosh_e(double x,double* result);+double gsl_sf_lncosh(double x);+int gsl_sf_polar_to_rect(double r,double theta,double* x,double* y);+int gsl_sf_rect_to_polar(double x,double y,double* r,double* theta);+int gsl_sf_sin_err_e(double x,double dx,double* result);+int gsl_sf_cos_err_e(double x,double dx,double* result);+int gsl_sf_angle_restrict_symm_e(double* theta);+double gsl_sf_angle_restrict_symm(double theta);+int gsl_sf_angle_restrict_pos_e(double* theta);+double gsl_sf_angle_restrict_pos(double theta);+int gsl_sf_angle_restrict_symm_err_e(double theta,double* result);+int gsl_sf_angle_restrict_pos_err_e(double theta,double* result);
+ lib/Numeric/GSL/Special/zeta.h view
@@ -0,0 +1,14 @@+int gsl_sf_zeta_int_e(int n,double* result);+double gsl_sf_zeta_int(int n);+int gsl_sf_zeta_e(double s,double* result);+double gsl_sf_zeta(double s);+int gsl_sf_zetam1_e(double s,double* result);+double gsl_sf_zetam1(double s);+int gsl_sf_zetam1_int_e(int s,double* result);+double gsl_sf_zetam1_int(int s);+int gsl_sf_hzeta_e(double s,double q,double* result);+double gsl_sf_hzeta(double s,double q);+int gsl_sf_eta_int_e(int n,double* result);+double gsl_sf_eta_int(int n);+int gsl_sf_eta_e(double s,double* result);+double gsl_sf_eta(double s);
+ lib/Numeric/GSL/Vector.hs view
@@ -0,0 +1,144 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.GSL.Vector+-- Copyright   :  (c) Alberto Ruiz 2007+-- License     :  GPL-style+--+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>+-- Stability   :  provisional+-- Portability :  portable (uses FFI)+--+-- Low level interface to vector operations.+--+-----------------------------------------------------------------------------++module Numeric.GSL.Vector (+    FunCodeS(..), toScalarR,+    FunCodeV(..), vectorMapR, vectorMapC,+    FunCodeSV(..), vectorMapValR, vectorMapValC,+    FunCodeVV(..), vectorZipR, vectorZipC+) where++import Data.Packed.Internal.Common+import Data.Packed.Internal.Vector++import Complex+import Foreign++data FunCodeV = Sin+              | Cos+              | Tan+              | Abs+              | ASin+              | ACos+              | ATan+              | Sinh+              | Cosh+              | Tanh+              | ASinh+              | ACosh+              | ATanh+              | Exp+              | Log+              | Sign+              | Sqrt+              deriving Enum++data FunCodeSV = Scale+               | Recip+               | AddConstant+               | Negate+               | PowSV+               | PowVS+               deriving Enum++data FunCodeVV = Add+               | Sub+               | Mul+               | Div+               | Pow+               | ATan2+               deriving Enum++data FunCodeS = Norm2+              | AbsSum+              | MaxIdx+              | Max+              | MinIdx+              | Min+              deriving Enum++------------------------------------------------------------------++toScalarAux fun code v = unsafePerformIO $ do+    r <- createVector 1+    app2 (fun (fromEnum code)) vec v vec r "toScalarAux"+    return (r `at` 0)++vectorMapAux fun code v = unsafePerformIO $ do+    r <- createVector (dim v)+    app2 (fun (fromEnum code)) vec v vec r "vectorMapAux"+    return r++vectorMapValAux fun code val v = unsafePerformIO $ do+    r <- createVector (dim v)+    pval <- newArray [val]+    app2 (fun (fromEnum code) pval) vec v vec r "vectorMapValAux"+    free pval+    return r++vectorZipAux fun code u v = unsafePerformIO $ do+    r <- createVector (dim u)+    app3 (fun (fromEnum code)) vec u vec v vec r "vectorZipAux"+    return r++---------------------------------------------------------------------++-- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.+toScalarR :: FunCodeS -> Vector Double -> Double+toScalarR oper =  toScalarAux c_toScalarR (fromEnum oper)++foreign import ccall safe "gsl-aux.h toScalarR" c_toScalarR :: Int -> TVV++------------------------------------------------------------------++-- | map of real vectors with given function+vectorMapR :: FunCodeV -> Vector Double -> Vector Double+vectorMapR = vectorMapAux c_vectorMapR++foreign import ccall safe "gsl-aux.h mapR" c_vectorMapR :: Int -> TVV++-- | map of complex vectors with given function+vectorMapC :: FunCodeV -> Vector (Complex Double) -> Vector (Complex Double)+vectorMapC oper = vectorMapAux c_vectorMapC (fromEnum oper)++foreign import ccall safe "gsl-aux.h mapC" c_vectorMapC :: Int -> TCVCV++-------------------------------------------------------------------++-- | map of real vectors with given function+vectorMapValR :: FunCodeSV -> Double -> Vector Double -> Vector Double+vectorMapValR oper = vectorMapValAux c_vectorMapValR (fromEnum oper)++foreign import ccall safe "gsl-aux.h mapValR" c_vectorMapValR :: Int -> Ptr Double -> TVV++-- | map of complex vectors with given function+vectorMapValC :: FunCodeSV -> Complex Double -> Vector (Complex Double) -> Vector (Complex Double)+vectorMapValC = vectorMapValAux c_vectorMapValC++foreign import ccall safe "gsl-aux.h mapValC" c_vectorMapValC :: Int -> Ptr (Complex Double) -> TCVCV++-------------------------------------------------------------------++-- | elementwise operation on real vectors+vectorZipR :: FunCodeVV -> Vector Double -> Vector Double -> Vector Double+vectorZipR = vectorZipAux c_vectorZipR++foreign import ccall safe "gsl-aux.h zipR" c_vectorZipR :: Int -> TVVV++-- | elementwise operation on complex vectors+vectorZipC :: FunCodeVV -> Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double)+vectorZipC = vectorZipAux c_vectorZipC++foreign import ccall safe "gsl-aux.h zipC" c_vectorZipC :: Int -> TCVCVCV
+ lib/Numeric/GSL/gsl-aux.c view
@@ -0,0 +1,770 @@+#include "gsl-aux.h"+#include <gsl/gsl_blas.h>+#include <gsl/gsl_linalg.h>+#include <gsl/gsl_matrix.h>+#include <gsl/gsl_math.h>+#include <gsl/gsl_errno.h>+#include <gsl/gsl_fft_complex.h>+#include <gsl/gsl_eigen.h>+#include <gsl/gsl_integration.h>+#include <gsl/gsl_deriv.h>+#include <gsl/gsl_poly.h>+#include <gsl/gsl_multimin.h>+#include <gsl/gsl_complex.h>+#include <gsl/gsl_complex_math.h>+#include <string.h>+#include <stdio.h>++#define MACRO(B) do {B} while (0)+#define ERROR(CODE) MACRO(return CODE;)+#define REQUIRES(COND, CODE) MACRO(if(!(COND)) {ERROR(CODE);})+#define OK return 0;++#define MIN(A,B) ((A)<(B)?(A):(B))+#define MAX(A,B) ((A)>(B)?(A):(B))++#ifdef DBG+#define DEBUGMSG(M) printf("*** calling aux C function: %s\n",M);+#else+#define DEBUGMSG(M)+#endif++#define CHECK(RES,CODE) MACRO(if(RES) return CODE;)++#ifdef DBG+#define DEBUGMAT(MSG,X) printf(MSG" = \n"); gsl_matrix_fprintf(stdout,X,"%f"); printf("\n");+#else+#define DEBUGMAT(MSG,X)+#endif++#ifdef DBG+#define DEBUGVEC(MSG,X) printf(MSG" = \n"); gsl_vector_fprintf(stdout,X,"%f"); printf("\n");+#else+#define DEBUGVEC(MSG,X)+#endif++#define DVVIEW(A) gsl_vector_view A = gsl_vector_view_array(A##p,A##n)+#define DMVIEW(A) gsl_matrix_view A = gsl_matrix_view_array(A##p,A##r,A##c)+#define CVVIEW(A) gsl_vector_complex_view A = gsl_vector_complex_view_array((double*)A##p,A##n)+#define CMVIEW(A) gsl_matrix_complex_view A = gsl_matrix_complex_view_array((double*)A##p,A##r,A##c)+#define KDVVIEW(A) gsl_vector_const_view A = gsl_vector_const_view_array(A##p,A##n)+#define KDMVIEW(A) gsl_matrix_const_view A = gsl_matrix_const_view_array(A##p,A##r,A##c)+#define KCVVIEW(A) gsl_vector_complex_const_view A = gsl_vector_complex_const_view_array((double*)A##p,A##n)+#define KCMVIEW(A) gsl_matrix_complex_const_view A = gsl_matrix_complex_const_view_array((double*)A##p,A##r,A##c)++#define V(a) (&a.vector)+#define M(a) (&a.matrix)++#define GCVEC(A) int A##n, gsl_complex*A##p+#define KGCVEC(A) int A##n, const gsl_complex*A##p++#define BAD_SIZE 2000+#define BAD_CODE 2001+#define MEM      2002+#define BAD_FILE 2003+++void no_abort_on_error() {+    gsl_set_error_handler_off();+}+++int toScalarR(int code, KRVEC(x), RVEC(r)) { +    REQUIRES(rn==1,BAD_SIZE);+    DEBUGMSG("toScalarR");+    KDVVIEW(x);+    double res;+    switch(code) {+        case 0: { res = gsl_blas_dnrm2(V(x)); break; } +        case 1: { res = gsl_blas_dasum(V(x));  break; }+        case 2: { res = gsl_vector_max_index(V(x));  break; }+        case 3: { res = gsl_vector_max(V(x));  break; }+        case 4: { res = gsl_vector_min_index(V(x)); break; }+        case 5: { res = gsl_vector_min(V(x)); break; }+        default: ERROR(BAD_CODE);+    }+    rp[0] = res;+    OK+}+++inline double sign(double x) {+    if(x>0) {+        return +1.0;+    } else if (x<0) {+        return -1.0;+    } else {+        return 0.0;+    }+}+++#define OP(C,F) case C: { for(k=0;k<xn;k++) rp[k] = F(xp[k]); OK }+#define OPV(C,E) case C: { for(k=0;k<xn;k++) rp[k] = E; OK }+int mapR(int code, KRVEC(x), RVEC(r)) {+    int k;+    REQUIRES(xn == rn,BAD_SIZE);+    DEBUGMSG("mapR");+    switch (code) {+        OP(0,sin)+        OP(1,cos)+        OP(2,tan)+        OP(3,fabs)+        OP(4,asin)+        OP(5,acos)+        OP(6,atan) /* atan2 mediante vectorZip */+        OP(7,sinh)+        OP(8,cosh)+        OP(9,tanh)+        OP(10,gsl_asinh)+        OP(11,gsl_acosh)+        OP(12,gsl_atanh)+        OP(13,exp)+        OP(14,log)+        OP(15,sign)+        OP(16,sqrt)+        default: ERROR(BAD_CODE);+    }+}++int mapCAux(int code, KGCVEC(x), GCVEC(r)) {+    int k;+    REQUIRES(xn == rn,BAD_SIZE);+    DEBUGMSG("mapC");+    switch (code) {+        OP(0,gsl_complex_sin)+        OP(1,gsl_complex_cos)+        OP(2,gsl_complex_tan)++        OP(4,gsl_complex_arcsin)+        OP(5,gsl_complex_arccos)+        OP(6,gsl_complex_arctan)+        OP(7,gsl_complex_sinh)+        OP(8,gsl_complex_cosh)+        OP(9,gsl_complex_tanh)+        OP(10,gsl_complex_arcsinh)+        OP(11,gsl_complex_arccosh)+        OP(12,gsl_complex_arctanh)+        OP(13,gsl_complex_exp)+        OP(14,gsl_complex_log)++        OP(16,gsl_complex_sqrt)++        // gsl_complex_arg+        // gsl_complex_abs+        default: ERROR(BAD_CODE);+    }+}++int mapC(int code, KCVEC(x), CVEC(r)) {+    return mapCAux(code, xn, (gsl_complex*)xp, rn, (gsl_complex*)rp);+}+++/*+int scaleR(double* alpha, KRVEC(x), RVEC(r)) {+    REQUIRES(xn == rn,BAD_SIZE);+    DEBUGMSG("scaleR");+    KDVVIEW(x);+    DVVIEW(r);+    CHECK( gsl_vector_memcpy(V(r),V(x)) , MEM);+    int res = gsl_vector_scale(V(r),*alpha);+    CHECK(res,res);+    OK+}++int scaleC(gsl_complex *alpha, KCVEC(x), CVEC(r)) {+    REQUIRES(xn == rn,BAD_SIZE);+    DEBUGMSG("scaleC");+    //KCVVIEW(x);+    CVVIEW(r);+    gsl_vector_const_view vrx = gsl_vector_const_view_array((double*)xp,xn*2);+    gsl_vector_view vrr = gsl_vector_view_array((double*)rp,rn*2);+    CHECK(gsl_vector_memcpy(V(vrr),V(vrx)) , MEM);+    gsl_blas_zscal(*alpha,V(r)); // void !+    int res = 0; +    CHECK(res,res);+    OK+}++int addConstantR(double offs, KRVEC(x), RVEC(r)) { +    REQUIRES(xn == rn,BAD_SIZE); +    DEBUGMSG("addConstantR");+    KDVVIEW(x);+    DVVIEW(r);+    CHECK(gsl_vector_memcpy(V(r),V(x)), MEM);+    int res = gsl_vector_add_constant(V(r),offs);+    CHECK(res,res);+    OK+}++*/++++int mapValR(int code, double* pval, KRVEC(x), RVEC(r)) {+    int k;+    double val = *pval;+    REQUIRES(xn == rn,BAD_SIZE);+    DEBUGMSG("mapValR");+    switch (code) {+        OPV(0,val*xp[k])+        OPV(1,val/xp[k])+        OPV(2,val+xp[k])+        OPV(3,val-xp[k])+        OPV(4,pow(val,xp[k]))+        OPV(5,pow(xp[k],val))+        default: ERROR(BAD_CODE);+    }+}++int mapValCAux(int code, gsl_complex* pval, KGCVEC(x), GCVEC(r)) {+    int k;+    gsl_complex val = *pval;+    REQUIRES(xn == rn,BAD_SIZE);+    DEBUGMSG("mapValC");+    switch (code) {+        OPV(0,gsl_complex_mul(val,xp[k]))+        OPV(1,gsl_complex_div(val,xp[k]))+        OPV(2,gsl_complex_add(val,xp[k]))+        OPV(3,gsl_complex_sub(val,xp[k]))+        OPV(4,gsl_complex_pow(val,xp[k]))+        OPV(5,gsl_complex_pow(xp[k],val))+        default: ERROR(BAD_CODE);+    }+}++int mapValC(int code, gsl_complex* val, KCVEC(x), CVEC(r)) {+    return mapValCAux(code, val, xn, (gsl_complex*)xp, rn, (gsl_complex*)rp);+}+++#define OPZE(C,msg,E) case C: {DEBUGMSG(msg) for(k=0;k<an;k++) rp[k] = E(ap[k],bp[k]); OK }+#define OPZV(C,msg,E) case C: {DEBUGMSG(msg) res = E(V(r),V(b)); CHECK(res,res); OK }+int zipR(int code, KRVEC(a), KRVEC(b), RVEC(r)) {+    REQUIRES(an == bn && an == rn, BAD_SIZE);+    int k;+    switch(code) {+        OPZE(4,"zipR Pow",pow)+        OPZE(5,"zipR ATan2",atan2)+    }+    KDVVIEW(a);+    KDVVIEW(b);+    DVVIEW(r);+    gsl_vector_memcpy(V(r),V(a));+    int res;+    switch(code) {+        OPZV(0,"zipR Add",gsl_vector_add)+        OPZV(1,"zipR Sub",gsl_vector_sub)+        OPZV(2,"zipR Mul",gsl_vector_mul)+        OPZV(3,"zipR Div",gsl_vector_div)+        default: ERROR(BAD_CODE);+    }+}+++int zipCAux(int code, KGCVEC(a), KGCVEC(b), GCVEC(r)) {+    REQUIRES(an == bn && an == rn, BAD_SIZE);+    int k;+    switch(code) {+        OPZE(0,"zipC Add",gsl_complex_add)+        OPZE(1,"zipC Sub",gsl_complex_sub)+        OPZE(2,"zipC Mul",gsl_complex_mul)+        OPZE(3,"zipC Div",gsl_complex_div)+        OPZE(4,"zipC Pow",gsl_complex_pow)+        //OPZE(5,"zipR ATan2",atan2)+    }+    //KCVVIEW(a);+    //KCVVIEW(b);+    //CVVIEW(r);+    //gsl_vector_memcpy(V(r),V(a));+    //int res;+    switch(code) {+        default: ERROR(BAD_CODE);+    }+}+++int zipC(int code, KCVEC(a), KCVEC(b), CVEC(r)) {+    return zipCAux(code, an, (gsl_complex*)ap, bn, (gsl_complex*)bp, rn, (gsl_complex*)rp);+}+++++int luSolveR(KRMAT(a),KRMAT(b),RMAT(r)) {+    REQUIRES(ar==ac && ac==br && ar==rr && bc==rc,BAD_SIZE);+    DEBUGMSG("luSolveR");+    KDMVIEW(a);+    KDMVIEW(b);+    DMVIEW(r);+    int res;+    gsl_matrix *LU = gsl_matrix_alloc(ar,ar);+    CHECK(!LU,MEM);+    int s;+    gsl_permutation * p = gsl_permutation_alloc (ar);+    CHECK(!p,MEM);+    CHECK(gsl_matrix_memcpy(LU,M(a)),MEM);+    res = gsl_linalg_LU_decomp(LU, p, &s);+    CHECK(res,res);+    int c;++    for (c=0; c<bc; c++) {+        gsl_vector_const_view colb = gsl_matrix_const_column (M(b), c);+        gsl_vector_view colr = gsl_matrix_column (M(r), c);+        res = gsl_linalg_LU_solve (LU, p, V(colb), V(colr));+        CHECK(res,res);+    }+    gsl_permutation_free(p);+    gsl_matrix_free(LU);+    OK+}+++int luSolveC(KCMAT(a),KCMAT(b),CMAT(r)) {+    REQUIRES(ar==ac && ac==br && ar==rr && bc==rc,BAD_SIZE);+    DEBUGMSG("luSolveC");+    KCMVIEW(a);+    KCMVIEW(b);+    CMVIEW(r);+    gsl_matrix_complex *LU = gsl_matrix_complex_alloc(ar,ar);+    CHECK(!LU,MEM);+    int s;+    gsl_permutation * p = gsl_permutation_alloc (ar);+    CHECK(!p,MEM);+    CHECK(gsl_matrix_complex_memcpy(LU,M(a)),MEM);+    int res;+    res = gsl_linalg_complex_LU_decomp(LU, p, &s);+    CHECK(res,res);+    int c;+    for (c=0; c<bc; c++) {+        gsl_vector_complex_const_view colb = gsl_matrix_complex_const_column (M(b), c);+        gsl_vector_complex_view colr = gsl_matrix_complex_column (M(r), c);+        res = gsl_linalg_complex_LU_solve (LU, p, V(colb), V(colr));+        CHECK(res,res);+    }+    gsl_permutation_free(p);+    gsl_matrix_complex_free(LU);+    OK+}+++int luRaux(KRMAT(a),RVEC(b)) {+    REQUIRES(ar==ac && bn==ar*ar+ar+1,BAD_SIZE);+    DEBUGMSG("luRaux");+    KDMVIEW(a);+    //DVVIEW(b);+    gsl_matrix_view LU = gsl_matrix_view_array(bp,ar,ac);+    int s;+    gsl_permutation * p = gsl_permutation_alloc (ar);+    CHECK(!p,MEM);+    CHECK(gsl_matrix_memcpy(M(LU),M(a)),MEM);+    gsl_linalg_LU_decomp(M(LU), p, &s);+    bp[ar*ar] = s;+    int k;+    for (k=0; k<ar; k++) {+        bp[ar*ar+k+1] = gsl_permutation_get(p,k);+    }+    gsl_permutation_free(p);+    OK+}++int luCaux(KCMAT(a),CVEC(b)) {+    REQUIRES(ar==ac && bn==ar*ar+ar+1,BAD_SIZE);+    DEBUGMSG("luCaux");+    KCMVIEW(a);+    //DVVIEW(b);+    gsl_matrix_complex_view LU = gsl_matrix_complex_view_array((double*)bp,ar,ac);+    int s;+    gsl_permutation * p = gsl_permutation_alloc (ar);+    CHECK(!p,MEM);+    CHECK(gsl_matrix_complex_memcpy(M(LU),M(a)),MEM);+    int res;+    res = gsl_linalg_complex_LU_decomp(M(LU), p, &s);+    CHECK(res,res);+    ((double*)bp)[2*ar*ar] = s;+    ((double*)bp)[2*ar*ar+1] = 0;+    int k;+    for (k=0; k<ar; k++) {+        ((double*)bp)[2*ar*ar+2*k+2] = gsl_permutation_get(p,k);+        ((double*)bp)[2*ar*ar+2*k+2+1] = 0;+    }+    gsl_permutation_free(p);+    OK+}++int svd(KRMAT(a),RMAT(u), RVEC(s),RMAT(v)) {+    REQUIRES(ar==ur && ac==uc && ac==sn && ac==vr && ac==vc,BAD_SIZE);+    DEBUGMSG("svd");+    KDMVIEW(a);+    DMVIEW(u);+    DVVIEW(s);+    DMVIEW(v);+    gsl_vector  *workv = gsl_vector_alloc(ac);+    CHECK(!workv,MEM);+    gsl_matrix  *workm = gsl_matrix_alloc(ac,ac);+    CHECK(!workm,MEM);+    CHECK(gsl_matrix_memcpy(M(u),M(a)),MEM);+    // int res = gsl_linalg_SV_decomp_jacobi (&U.matrix, &V.matrix, &S.vector);+    // doesn't work +    //int res = gsl_linalg_SV_decomp (&U.matrix, &V.matrix, &S.vector, workv);+    int res = gsl_linalg_SV_decomp_mod (M(u), workm, M(v), V(s), workv);+    CHECK(res,res);+    //gsl_matrix_transpose(M(v));+    gsl_vector_free(workv);+    gsl_matrix_free(workm);+    OK+}+++// for real symmetric matrices+int eigensystemR(KRMAT(x),RVEC(l),RMAT(v)) {+    REQUIRES(xr==xc && xr==ln && xr==vr && vr==vc,BAD_SIZE);+    DEBUGMSG("eigensystemR (gsl_eigen_symmv)");+    KDMVIEW(x);+    DVVIEW(l);+    DMVIEW(v);+    gsl_matrix *XC = gsl_matrix_alloc(xr,xr);+    gsl_matrix_memcpy(XC,M(x)); // needed because the argument is destroyed+                                // many thanks to Nico Mahlo for the bug report +    gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (xc);+    int res = gsl_eigen_symmv (XC, V(l), M(v), w);+    CHECK(res,res);+    gsl_eigen_symmv_free (w);+    gsl_matrix_free(XC);+    gsl_eigen_symmv_sort (V(l), M(v), GSL_EIGEN_SORT_ABS_DESC);+    OK+}++// for hermitian matrices+int eigensystemC(KCMAT(x),RVEC(l),CMAT(v)) {+    REQUIRES(xr==xc && xr==ln && xr==vr && vr==vc,BAD_SIZE);+    DEBUGMSG("eigensystemC");+    KCMVIEW(x);+    DVVIEW(l);+    CMVIEW(v);+    gsl_matrix_complex *XC = gsl_matrix_complex_alloc(xr,xr);+    gsl_matrix_complex_memcpy(XC,M(x)); // again needed because the argument is destroyed+    gsl_eigen_hermv_workspace * w = gsl_eigen_hermv_alloc (xc);+    int res = gsl_eigen_hermv (XC, V(l), M(v), w);+    CHECK(res,res);+    gsl_eigen_hermv_free (w);+    gsl_matrix_complex_free(XC);+    gsl_eigen_hermv_sort (V(l), M(v), GSL_EIGEN_SORT_ABS_DESC);+    OK+}++int QR(KRMAT(x),RMAT(q),RMAT(r)) {+    REQUIRES(xr==rr && xc==rc && qr==qc && xr==qr,BAD_SIZE);+    DEBUGMSG("QR");+    KDMVIEW(x);+    DMVIEW(q);+    DMVIEW(r);+    gsl_matrix * a = gsl_matrix_alloc(xr,xc);+    gsl_vector * tau = gsl_vector_alloc(MIN(xr,xc));+    gsl_matrix_memcpy(a,M(x));+    int res = gsl_linalg_QR_decomp(a,tau);+    CHECK(res,res);+    gsl_linalg_QR_unpack(a,tau,M(q),M(r));+    gsl_vector_free(tau);+    gsl_matrix_free(a);+    OK+}++int QRpacked(KRMAT(x),RMAT(qr),RVEC(tau)) {+    //REQUIRES(xr==rr && xc==rc && qr==qc && xr==qr,BAD_SIZE);+    DEBUGMSG("QRpacked");+    KDMVIEW(x);+    DMVIEW(qr);+    DVVIEW(tau);+    //gsl_matrix * a = gsl_matrix_alloc(xr,xc);+    //gsl_vector * tau = gsl_vector_alloc(MIN(xr,xc));+    gsl_matrix_memcpy(M(qr),M(x));+    int res = gsl_linalg_QR_decomp(M(qr),V(tau));+    CHECK(res,res);+    OK+}+++int QRunpack(KRMAT(xqr),KRVEC(tau),RMAT(q),RMAT(r)) {+    //REQUIRES(xr==rr && xc==rc && qr==qc && xr==qr,BAD_SIZE);+    DEBUGMSG("QRunpack");+    KDMVIEW(xqr);+    KDVVIEW(tau);+    DMVIEW(q);+    DMVIEW(r);+    gsl_linalg_QR_unpack(M(xqr),V(tau),M(q),M(r));+    OK+}+++int cholR(KRMAT(x),RMAT(l)) {+    REQUIRES(xr==xc && lr==xr && lr==lc,BAD_SIZE);+    DEBUGMSG("cholR");+    KDMVIEW(x);+    DMVIEW(l);+    gsl_matrix_memcpy(M(l),M(x));+    int res = gsl_linalg_cholesky_decomp(M(l));+    CHECK(res,res);+    int r,c;+    for (r=0; r<xr-1; r++) {+        for(c=r+1; c<xc; c++) {+            lp[r*lc+c] = 0.;+        }+    }+    OK+}++int cholC(KCMAT(x),CMAT(l)) {+    REQUIRES(xr==xc && lr==xr && lr==lc,BAD_SIZE);+    DEBUGMSG("cholC");+    KCMVIEW(x);+    CMVIEW(l);+    gsl_matrix_complex_memcpy(M(l),M(x));+    int res = 0; // gsl_linalg_complex_cholesky_decomp(M(l));+    CHECK(res,res);+    gsl_complex zero = {0.,0.};+    int r,c;+    for (r=0; r<xr-1; r++) {+        for(c=r+1; c<xc; c++) {+            lp[r*lc+c] = zero;+        }+    }+    OK+}++int fft(int code, KCVEC(X), CVEC(R)) {+    REQUIRES(Xn == Rn,BAD_SIZE);+    DEBUGMSG("fft");+    int s = Xn;+    gsl_fft_complex_wavetable * wavetable = gsl_fft_complex_wavetable_alloc (s);+    gsl_fft_complex_workspace * workspace = gsl_fft_complex_workspace_alloc (s);+    gsl_vector_const_view X = gsl_vector_const_view_array((double*)Xp, 2*Xn);+    gsl_vector_view R = gsl_vector_view_array((double*)Rp, 2*Rn);+    gsl_blas_dcopy(&X.vector,&R.vector);+    if(code==0) {+        gsl_fft_complex_forward ((double*)Rp, 1, s, wavetable, workspace);+    } else {+        gsl_fft_complex_inverse ((double*)Rp, 1, s, wavetable, workspace);+    }+    gsl_fft_complex_wavetable_free (wavetable);+    gsl_fft_complex_workspace_free (workspace);+    OK+}+++int integrate_qng(double f(double, void*), double a, double b, double prec,+                   double *result, double*error) {+    DEBUGMSG("integrate_qng");+    gsl_function F;+    F.function = f;+    F.params = NULL;+    size_t neval;+    int res = gsl_integration_qng (&F, a,b, 0, prec, result, error, &neval); +    CHECK(res,res);+    OK+}++int integrate_qags(double f(double,void*), double a, double b, double prec, int w, +               double *result, double* error) {+    DEBUGMSG("integrate_qags");+    gsl_integration_workspace * wk = gsl_integration_workspace_alloc (w);+    gsl_function F;+    F.function = f;+    F.params = NULL;+    int res = gsl_integration_qags (&F, a,b, 0, prec, w,wk, result, error); +    CHECK(res,res);+    gsl_integration_workspace_free (wk); +    OK+}++int polySolve(KRVEC(a), CVEC(z)) {+    DEBUGMSG("polySolve");+    REQUIRES(an>1,BAD_SIZE);+    gsl_poly_complex_workspace * w = gsl_poly_complex_workspace_alloc (an);+    int res = gsl_poly_complex_solve ((double*)ap, an, w, (double*)zp);+    CHECK(res,res);+    gsl_poly_complex_workspace_free (w);+    OK;+}++int matrix_fscanf(char*filename, RMAT(a)) {+    DEBUGMSG("gsl_matrix_fscanf");+    //printf(filename); printf("\n");+    DMVIEW(a);+    FILE * f = fopen(filename,"r");+    CHECK(!f,BAD_FILE);+    int res = gsl_matrix_fscanf(f, M(a));+    CHECK(res,res);+    fclose (f);+    OK+}++//---------------------------------------------------------------++typedef double Trawfun(int, double*);++double only_f_aux_min(const gsl_vector*x, void *pars) {+    Trawfun * f = (Trawfun*) pars;  +    double* p = (double*)calloc(x->size,sizeof(double));+    int k;+    for(k=0;k<x->size;k++) {+        p[k] = gsl_vector_get(x,k);+    }  +    double res = f(x->size,p);+    free(p);+    return res;+}++// this version returns info about intermediate steps+int minimize(double f(int, double*), double tolsize, int maxit, +                 KRVEC(xi), KRVEC(sz), RMAT(sol)) {+    REQUIRES(xin==szn && solr == maxit && solc == 3+xin,BAD_SIZE);+    DEBUGMSG("minimizeList (nmsimplex)");+    gsl_multimin_function my_func;+    // extract function from pars+    my_func.f = only_f_aux_min;+    my_func.n = xin; +    my_func.params = f;+    size_t iter = 0;+    int status;+    double size;+    const gsl_multimin_fminimizer_type *T;+    gsl_multimin_fminimizer *s = NULL;+    // Initial vertex size vector +    KDVVIEW(sz);+    // Starting point+    KDVVIEW(xi);+    // Minimizer nmsimplex, without derivatives+    T = gsl_multimin_fminimizer_nmsimplex;+    s = gsl_multimin_fminimizer_alloc (T, my_func.n);+    gsl_multimin_fminimizer_set (s, &my_func, V(xi), V(sz));+    do {+        status = gsl_multimin_fminimizer_iterate (s);+        size = gsl_multimin_fminimizer_size (s);++        solp[iter*solc+0] = iter;+        solp[iter*solc+1] = s->fval;+        solp[iter*solc+2] = size;++        int k;+        for(k=0;k<xin;k++) {+            solp[iter*solc+k+3] = gsl_vector_get(s->x,k);+        }+        status = gsl_multimin_test_size (size, tolsize);+        iter++;+    } while (status == GSL_CONTINUE && iter < maxit);+    int i,j;+    for (i=iter; i<solr; i++) {+        solp[i*solc+0] = iter;+        for(j=1;j<solc;j++) {+            solp[i*solc+j]=0.;+        }+    }+    gsl_multimin_fminimizer_free(s);+    OK+}++// working with the gradient++typedef struct {double (*f)(int, double*); void (*df)(int, double*, double*);} Tfdf;++double f_aux_min(const gsl_vector*x, void *pars) {+    Tfdf * fdf = ((Tfdf*) pars);+    double* p = (double*)calloc(x->size,sizeof(double));+    int k;+    for(k=0;k<x->size;k++) {+        p[k] = gsl_vector_get(x,k);+    }+    double res = fdf->f(x->size,p);+    free(p);+    return res;+}+++void df_aux_min(const gsl_vector * x, void * pars, gsl_vector * g) {+    Tfdf * fdf = ((Tfdf*) pars);  +    double* p = (double*)calloc(x->size,sizeof(double));+    double* q = (double*)calloc(x->size,sizeof(double));+    int k;+    for(k=0;k<x->size;k++) {+        p[k] = gsl_vector_get(x,k);+    }++    fdf->df(x->size,p,q);++    for(k=0;k<x->size;k++) {+        gsl_vector_set(g,k,q[k]);+    }+    free(p);+    free(q);+}++void fdf_aux_min(const gsl_vector * x, void * pars, double * f, gsl_vector * g) {+    *f = f_aux_min(x,pars);+    df_aux_min(x,pars,g);+}++// conjugate gradient+int minimizeWithDeriv(double f(int, double*), void df(int, double*, double*), +                      double initstep, double minimpar, double tolgrad, int maxit, +                      KRVEC(xi), RMAT(sol)) {+    REQUIRES(solr == maxit && solc == 2+xin,BAD_SIZE);+    DEBUGMSG("minimizeWithDeriv (conjugate_fr)");+    gsl_multimin_function_fdf my_func;+    // extract function from pars+    my_func.f = f_aux_min;+    my_func.df = df_aux_min;+    my_func.fdf = fdf_aux_min;+    my_func.n = xin; +    Tfdf stfdf;+    stfdf.f = f;+    stfdf.df = df;+    my_func.params = &stfdf;+    size_t iter = 0;+    int status;+    const gsl_multimin_fdfminimizer_type *T;+    gsl_multimin_fdfminimizer *s = NULL;+    // Starting point+    KDVVIEW(xi);+    // conjugate gradient fr+    T = gsl_multimin_fdfminimizer_conjugate_fr;+    s = gsl_multimin_fdfminimizer_alloc (T, my_func.n);+    gsl_multimin_fdfminimizer_set (s, &my_func, V(xi), initstep, minimpar);+    do {+        status = gsl_multimin_fdfminimizer_iterate (s);+        solp[iter*solc+0] = iter;+        solp[iter*solc+1] = s->f;+        int k;+        for(k=0;k<xin;k++) {+            solp[iter*solc+k+2] = gsl_vector_get(s->x,k);+        }+        status = gsl_multimin_test_gradient (s->gradient, tolgrad);+        iter++;+    } while (status == GSL_CONTINUE && iter < maxit);+    int i,j;+    for (i=iter; i<solr; i++) {+        solp[i*solc+0] = iter;+        for(j=1;j<solc;j++) {+            solp[i*solc+j]=0.;+        }+    }+    gsl_multimin_fdfminimizer_free(s);+    OK+}+++int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr)+{+    gsl_function F;+    F.function = f;+    F.params = 0;++    if(code==0) return gsl_deriv_central (&F, x, h, result, abserr);++    if(code==1) return gsl_deriv_forward (&F, x, h, result, abserr);++    if(code==2) return gsl_deriv_backward (&F, x, h, result, abserr);++    return 0;+}
+ lib/Numeric/GSL/gsl-aux.h view
@@ -0,0 +1,65 @@+#include <gsl/gsl_complex.h>++#define RVEC(A) int A##n, double*A##p+#define RMAT(A) int A##r, int A##c, double* A##p+#define KRVEC(A) int A##n, const double*A##p+#define KRMAT(A) int A##r, int A##c, const double* A##p++#define CVEC(A) int A##n, gsl_complex*A##p+#define CMAT(A) int A##r, int A##c, gsl_complex* A##p+#define KCVEC(A) int A##n, const gsl_complex*A##p+#define KCMAT(A) int A##r, int A##c, const gsl_complex* A##p++void no_abort_on_error();++int toScalarR(int code, KRVEC(x), RVEC(r));+/* norm2, absdif, maximum, posmax, etc. */++int mapR(int code, KRVEC(x), RVEC(r));+int mapC(int code, KCVEC(x), CVEC(r));+/* sin cos tan etc. */++int mapValR(int code, double*, KRVEC(x), RVEC(r));+int mapValC(int code, gsl_complex*, KCVEC(x), CVEC(r));++int zipR(int code, KRVEC(a), KRVEC(b), RVEC(r));+int zipC(int code, KCVEC(a), KCVEC(b), CVEC(r));+++int luSolveR(KRMAT(a),KRMAT(b),RMAT(r)); +int luSolveC(KCMAT(a),KCMAT(b),CMAT(r));+int luRaux(KRMAT(a),RVEC(b));+int luCaux(KCMAT(a),CVEC(b));++int svd(KRMAT(x),RMAT(u), RVEC(s),RMAT(v));++int eigensystemR(KRMAT(x),RVEC(l),RMAT(v));+int eigensystemC(KCMAT(x),RVEC(l),CMAT(v));++int QR(KRMAT(x),RMAT(q),RMAT(r));++int QRpacked(KRMAT(x),RMAT(qr),RVEC(tau));+int QRunpack(KRMAT(qr),KRVEC(tau),RMAT(q),RMAT(r));++int cholR(KRMAT(x),RMAT(l));++int cholC(KCMAT(x),CMAT(l));++int fft(int code, KCVEC(a), CVEC(b));++int integrate_qng(double f(double, void*), double a, double b, double prec,+                   double *result, double*error);++int integrate_qags(double f(double,void*), double a, double b, double prec, int w, +               double *result, double* error);++int polySolve(KRVEC(a), CVEC(z));++int minimize(double f(int, double*), double tolsize, int maxit, +                 KRVEC(xi), KRVEC(sz), RMAT(sol));++int minimizeWithDeriv(double f(int, double*), void df(int, double*, double*),+                      double initstep, double minimpar, double tolgrad, int maxit, +                      KRVEC(xi), RMAT(sol));++int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr);
+ lib/Numeric/LinearAlgebra.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.LinearAlgebra+Copyright   :  (c) Alberto Ruiz 2006-7+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Basic matrix computations implemented by BLAS, LAPACK and GSL.++-}+-----------------------------------------------------------------------------+module Numeric.LinearAlgebra (+    module Data.Packed,+    module Numeric.LinearAlgebra.Linear,+    module Numeric.LinearAlgebra.Algorithms,+    module Numeric.LinearAlgebra.Instances,+    module Numeric.LinearAlgebra.Interface+) where++import Data.Packed+import Numeric.LinearAlgebra.Linear+import Numeric.LinearAlgebra.Algorithms+import Numeric.LinearAlgebra.Instances()+import Numeric.LinearAlgebra.Interface
+ lib/Numeric/LinearAlgebra/Algorithms.hs view
@@ -0,0 +1,459 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.LinearAlgebra.Algorithms+Copyright   :  (c) Alberto Ruiz 2006-7+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++A generic interface for some common functions. Using it we can write higher level algorithms+and testing properties both for real and complex matrices.++In any case, the specific functions for particular base types can also be explicitly+imported from "Numeric.LinearAlgebra.LAPACK".++-}+-----------------------------------------------------------------------------++module Numeric.LinearAlgebra.Algorithms (+-- * Linear Systems+    linearSolve,+    inv, pinv,+    pinvTol, det, rank, rcond,+-- * Matrix factorizations+-- ** Singular value decomposition+    svd,+    full, economy, --thin,+-- ** Eigensystems+    eig, eigSH,+-- ** QR+    qr,+-- ** Cholesky+    chol,+-- ** Hessenberg+    hess,+-- ** Schur+    schur,+-- * Matrix functions+    expm,+    sqrtm,+    matFunc,+-- * Nullspace+    nullspacePrec,+    nullVector,+-- * Norms+    Normed(..), NormType(..),+-- * Misc+    ctrans,+    eps, i,+-- * Util+    haussholder,+    unpackQR, unpackHess,+    Field(linearSolveSVD,lu,eigSH',cholSH)+) where+++import Data.Packed.Internal hiding (fromComplex, toComplex, comp, conj)+import Data.Packed+import qualified Numeric.GSL.Matrix as GSL+import Numeric.GSL.Vector+import Numeric.LinearAlgebra.LAPACK as LAPACK+import Complex+import Numeric.LinearAlgebra.Linear+import Data.List(foldl1')++-- | Auxiliary typeclass used to define generic computations for both real and complex matrices.+class (Normed (Matrix t), Linear Matrix t) => Field t where+    -- | Singular value decomposition using lapack's dgesvd or zgesvd.+    svd         :: Matrix t -> (Matrix t, Vector Double, Matrix t)+    lu          :: Matrix t -> (Matrix t, Matrix t, [Int], t)+    -- | Solution of a general linear system (for several right-hand sides) using lapacks' dgesv and zgesv.+    --  See also other versions of linearSolve in "Numeric.LinearAlgebra.LAPACK".+    linearSolve :: Matrix t -> Matrix t -> Matrix t+    linearSolveSVD :: Matrix t -> Matrix t -> Matrix t+    -- | Eigenvalues and eigenvectors of a general square matrix using lapack's dgeev or zgeev.+    --+    -- If @(s,v) = eig m@ then @m \<> v == v \<> diag s@+    eig         :: Matrix t -> (Vector (Complex Double), Matrix (Complex Double))+    -- | Similar to eigSH without checking that the input matrix is hermitian or symmetric.+    eigSH'      :: Matrix t -> (Vector Double, Matrix t)+    -- | Similar to chol without checking that the input matrix is hermitian or symmetric.+    cholSH      :: Matrix t -> Matrix t+    -- | QR factorization using lapack's dgeqr2 or zgeqr2.+    --+    -- If @(q,r) = qr m@ then @m == q \<> r@, where q is unitary and r is upper triangular.+    qr          :: Matrix t -> (Matrix t, Matrix t)+    -- | Hessenberg factorization using lapack's dgehrd or zgehrd.+    --+    -- If @(p,h) = hess m@ then @m == p \<> h \<> ctrans p@, where p is unitary+    -- and h is in upper Hessenberg form.+    hess        :: Matrix t -> (Matrix t, Matrix t)+    -- | Schur factorization using lapack's dgees or zgees.+    --+    -- If @(u,s) = schur m@ then @m == u \<> s \<> ctrans u@, where u is unitary+    -- and s is a Shur matrix. A complex Schur matrix is upper triangular. A real Schur matrix is+    -- upper triangular in 2x2 blocks.+    --+    -- \"Anything that the Jordan decomposition can do, the Schur decomposition+    -- can do better!\" (Van Loan)+    schur       :: Matrix t -> (Matrix t, Matrix t)+    -- | Conjugate transpose.+    ctrans :: Matrix t -> Matrix t+++instance Field Double where+    svd = svdR+    lu  = GSL.luR+    linearSolve = linearSolveR+    linearSolveSVD = linearSolveSVDR Nothing+    ctrans = trans+    eig = eigR+    eigSH' = eigS+    cholSH = cholS+    qr = GSL.unpackQR . qrR+    hess = unpackHess hessR+    schur = schurR++instance Field (Complex Double) where+    svd = svdC+    lu  = GSL.luC+    linearSolve = linearSolveC+    linearSolveSVD = linearSolveSVDC Nothing+    ctrans = conj . trans+    eig = eigC+    eigSH' = eigH+    cholSH = cholH+    qr = unpackQR . qrC+    hess = unpackHess hessC+    schur = schurC++-- | Eigenvalues and Eigenvectors of a complex hermitian or real symmetric matrix using lapack's dsyev or zheev.+--+-- If @(s,v) = eigSH m@ then @m == v \<> diag s \<> ctrans v@+eigSH :: Field t => Matrix t -> (Vector Double, Matrix t)+eigSH m | m `equal` ctrans m = eigSH' m+        | otherwise = error "eigSH requires complex hermitian or real symmetric matrix"++-- | Cholesky factorization of a positive definite hermitian or symmetric matrix using lapack's dpotrf or zportrf.+--+-- If @c = chol m@ then @m == c \<> ctrans c@.+chol :: Field t => Matrix t ->  Matrix t+chol m | m `equal` ctrans m = cholSH m+       | otherwise = error "chol requires positive definite complex hermitian or real symmetric matrix"++square m = rows m == cols m++det :: Field t => Matrix t -> t+det m | square m = s * (product $ toList $ takeDiag $ u)+      | otherwise = error "det of nonsquare matrix"+    where (_,u,_,s) = lu m++-- | Inverse of a square matrix using lapacks' dgesv and zgesv.+inv :: Field t => Matrix t -> Matrix t+inv m | square m = m `linearSolve` ident (rows m)+      | otherwise = error "inv of nonsquare matrix"++-- | Pseudoinverse of a general matrix using lapack's dgelss or zgelss.+pinv :: Field t => Matrix t -> Matrix t+pinv m = linearSolveSVD m (ident (rows m))++-- | A version of 'svd' which returns an appropriate diagonal matrix with the singular values.+--+-- If @(u,d,v) = full svd m@ then @m == u \<> d \<> trans v@.+full :: Element t +     => (Matrix t -> (Matrix t, Vector Double, Matrix t)) -> Matrix t -> (Matrix t, Matrix Double, Matrix t)+full svd' m = (u, d ,v) where+    (u,s,v) = svd' m+    d = diagRect s r c+    r = rows m+    c = cols m++-- | A version of 'svd' which returns only the nonzero singular values and the corresponding rows and columns of the rotations.+--+-- If @(u,s,v) = economy svd m@ then @m == u \<> diag s \<> trans v@.+economy :: Element t +        => (Matrix t -> (Matrix t, Vector Double, Matrix t)) -> Matrix t -> (Matrix t, Vector Double, Matrix t)+economy svd' m = (u', subVector 0 d s, v') where+    (u,s,v) = svd' m+    sl@(g:_) = toList s+    s' = fromList . filter (>tol) $ sl+    t = 1+    tol = (fromIntegral (max r c) * g * t * eps)+    r = rows m+    c = cols m+    d = dim s'+    u' = takeColumns d u+    v' = takeColumns d v+++-- | The machine precision of a Double: @eps = 2.22044604925031e-16@ (the value used by GNU-Octave).+eps :: Double+eps =  2.22044604925031e-16++-- | The imaginary unit: @i = 0.0 :+ 1.0@+i :: Complex Double+i = 0:+1+++-- matrix product+mXm :: (Num t, Field t) => Matrix t -> Matrix t -> Matrix t+mXm = multiply++-- matrix - vector product+mXv :: (Num t, Field t) => Matrix t -> Vector t -> Vector t+mXv m v = flatten $ m `mXm` (asColumn v)++-- vector - matrix product+vXm :: (Num t, Field t) => Vector t -> Matrix t -> Vector t+vXm v m = flatten $ (asRow v) `mXm` m+++---------------------------------------------------------------------------++norm2 :: Vector Double -> Double+norm2 = toScalarR Norm2++norm1 :: Vector Double -> Double+norm1 = toScalarR AbsSum++data NormType = Infinity | PNorm1 | PNorm2 -- PNorm Int++pnormRV PNorm2 = norm2+pnormRV PNorm1 = norm1+pnormRV Infinity = vectorMax . vectorMapR Abs+--pnormRV _ = error "pnormRV not yet defined"++pnormCV PNorm2 = norm2 . asReal+pnormCV PNorm1 = norm1 . liftVector magnitude+pnormCV Infinity = vectorMax . liftVector magnitude+--pnormCV _ = error "pnormCV not yet defined"++pnormRM PNorm2 m = head (toList s) where (_,s,_) = svdR m+pnormRM PNorm1 m = vectorMax $ constant 1 (rows m) `vXm` liftMatrix (vectorMapR Abs) m+pnormRM Infinity m = vectorMax $ liftMatrix (vectorMapR Abs) m `mXv` constant 1 (cols m)+--pnormRM _ _ = error "p norm not yet defined"++pnormCM PNorm2 m = head (toList s) where (_,s,_) = svdC m+pnormCM PNorm1 m = vectorMax $ constant 1 (rows m) `vXm` liftMatrix (liftVector magnitude) m+pnormCM Infinity m = vectorMax $ liftMatrix (liftVector magnitude) m `mXv` constant 1 (cols m)+--pnormCM _ _ = error "p norm not yet defined"++-- | Objects which have a p-norm.+-- Using it you can define convenient shortcuts:+--+-- @norm2 x = pnorm PNorm2 x@+--+-- @frobenius m = norm2 . flatten $ m@+class Normed t where+    pnorm :: NormType -> t -> Double++instance Normed (Vector Double) where+    pnorm = pnormRV++instance Normed (Vector (Complex Double)) where+    pnorm = pnormCV++instance Normed (Matrix Double) where+    pnorm = pnormRM++instance Normed (Matrix (Complex Double)) where+    pnorm = pnormCM++-----------------------------------------------------------------------++-- | The nullspace of a matrix from its SVD decomposition.+nullspacePrec :: Field t+              => Double     -- ^ relative tolerance in 'eps' units+              -> Matrix t   -- ^ input matrix+              -> [Vector t] -- ^ list of unitary vectors spanning the nullspace+nullspacePrec t m = ns where+    (_,s,v) = svd m+    sl@(g:_) = toList s+    tol = (fromIntegral (max (rows m) (cols m)) * g * t * eps)+    rank' = length (filter (> g*tol) sl)+    ns = drop rank' $ toRows $ ctrans v++-- | The nullspace of a matrix, assumed to be one-dimensional, with default tolerance (shortcut for @last . nullspacePrec 1@).+nullVector :: Field t => Matrix t -> Vector t+nullVector = last . nullspacePrec 1++------------------------------------------------------------------------++{-  Pseudoinverse of a real matrix with the desired tolerance, expressed as a+multiplicative factor of the default tolerance used by GNU-Octave (see 'pinv').++@\> let m = 'fromLists' [[1,0,    0]+                    ,[0,1,    0]+                    ,[0,0,1e-10]]+\ +\> 'pinv' m +1. 0.           0.+0. 1.           0.+0. 0. 10000000000.+\ +\> pinvTol 1E8 m+1. 0. 0.+0. 1. 0.+0. 0. 1.@++-}+--pinvTol :: Double -> Matrix Double -> Matrix Double+pinvTol t m = v' `mXm` diag s' `mXm` trans u' where+    (u,s,v) = svdR m+    sl@(g:_) = toList s+    s' = fromList . map rec $ sl+    rec x = if x < g*tol then 1 else 1/x+    tol = (fromIntegral (max r c) * g * t * eps)+    r = rows m+    c = cols m+    d = dim s+    u' = takeColumns d u+    v' = takeColumns d v++---------------------------------------------------------------------++-- many thanks, quickcheck!++haussholder :: (Field a) => a -> Vector a -> Matrix a+haussholder tau v = ident (dim v) `sub` (tau `scale` (w `mXm` ctrans w))+    where w = asColumn v+++zh k v = fromList $ replicate (k-1) 0 ++ (1:drop k xs)+              where xs = toList v++zt 0 v = v+zt k v = join [subVector 0 (dim v - k) v, constant 0 k]+++unpackQR :: (Field t) => (Matrix t, Vector t) -> (Matrix t, Matrix t)+unpackQR (pq, tau) = (q,r)+    where cs = toColumns pq+          m = rows pq+          n = cols pq+          mn = min m n+          r = fromColumns $ zipWith zt ([m-1, m-2 .. 1] ++ repeat 0) cs+          vs = zipWith zh [1..mn] cs+          hs = zipWith haussholder (toList tau) vs+          q = foldl1' mXm hs++unpackHess :: (Field t) => (Matrix t -> (Matrix t,Vector t)) -> Matrix t -> (Matrix t, Matrix t)+unpackHess hf m+    | rows m == 1 = ((1><1)[1],m)+    | otherwise = (uH . hf) m++uH (pq, tau) = (p,h)+    where cs = toColumns pq+          m = rows pq+          n = cols pq+          mn = min m n+          h = fromColumns $ zipWith zt ([m-2, m-3 .. 1] ++ repeat 0) cs+          vs = zipWith zh [2..mn] cs+          hs = zipWith haussholder (toList tau) vs+          p = foldl1' mXm hs++--------------------------------------------------------------------------++-- | Reciprocal of the 2-norm condition number of a matrix, computed from the SVD.+rcond :: Field t => Matrix t -> Double+rcond m = last s / head s+    where (_,s',_) = svd m+          s = toList s'++-- | Number of linearly independent rows or columns.+rank :: Field t => Matrix t -> Int+rank m | pnorm PNorm1 m < eps = 0+       | otherwise = dim s where (_,s,_) = economy svd m++{-+expm' m = case diagonalize (complex m) of+    Just (l,v) -> v `mXm` diag (exp l) `mXm` inv v+    Nothing -> error "Sorry, expm not yet implemented for non-diagonalizable matrices"+  where exp = vectorMapC Exp+-}++diagonalize m = if rank v == n+                    then Just (l,v)+                    else Nothing+    where n = rows m+          (l,v) = if m `equal` ctrans m+                    then let (l',v') = eigSH m in (real l', v')+                    else eig m++-- | Generic matrix functions for diagonalizable matrices. For instance:+--+-- @logm = matFunc log@+--+matFunc :: Field t => (Complex Double -> Complex Double) -> Matrix t -> Matrix (Complex Double)+matFunc f m = case diagonalize (complex m) of+    Just (l,v) -> v `mXm` diag (liftVector f l) `mXm` inv v+    Nothing -> error "Sorry, matFunc requires a diagonalizable matrix" ++--------------------------------------------------------------++golubeps :: Integer -> Integer -> Double+golubeps p q = a * fromIntegral b / fromIntegral c where+    a = 2^^(3-p-q)+    b = fact p * fact q+    c = fact (p+q) * fact (p+q+1)+    fact n = product [1..n]++epslist = [ (fromIntegral k, golubeps k k) | k <- [1..]]++geps delta = head [ k | (k,g) <- epslist, g<delta]++expGolub m = iterate msq f !! j+    where j = max 0 $ floor $ log2 $ pnorm Infinity m+          log2 x = log x / log 2+          a = m */ fromIntegral ((2::Int)^j)+          q = geps eps -- 7 steps+          eye = ident (rows m)+          work (k,c,x,n,d) = (k',c',x',n',d')+              where k' = k+1+                    c' = c * fromIntegral (q-k+1) / fromIntegral ((2*q-k+1)*k)+                    x' = a <> x+                    n' = n |+| (c' .* x')+                    d' = d |+| (((-1)^k * c') .* x')+          (_,_,_,nf,df) = iterate work (1,1,eye,eye,eye) !! q+          f = linearSolve df nf+          msq x = x <> x++          (<>) = multiply+          v */ x = scale (recip x) v+          (.*) = scale+          (|+|) = add++{- | Matrix exponential. It uses a direct translation of Algorithm 11.3.1 in Golub & Van Loan,+     based on a scaled Pade approximation.+-}+expm :: Field t => Matrix t -> Matrix t+expm = expGolub++--------------------------------------------------------------++{- | Matrix square root. Currently it uses a simple iterative algorithm described in Wikipedia.+It only works with invertible matrices that have a real solution. For diagonalizable matrices you can try @matFunc sqrt@.++@m = (2><2) [4,9+           ,0,4] :: Matrix Double@++@\>sqrtm m+(2><2)+ [ 2.0, 2.25+ , 0.0,  2.0 ]@+-}+sqrtm :: Field t => Matrix t -> Matrix t+sqrtm = sqrtmInv++sqrtmInv x = fst $ fixedPoint $ iterate f (x, ident (rows x))+    where fixedPoint (a:b:rest) | pnorm PNorm1 (fst a |-| fst b) < eps   = a+                                | otherwise = fixedPoint (b:rest)+          fixedPoint _ = error "fixedpoint with impossible inputs"+          f (y,z) = (0.5 .* (y |+| inv z),+                     0.5 .* (inv y |+| z))+          (.*) = scale+          (|+|) = add+          (|-|) = sub
+ lib/Numeric/LinearAlgebra/Instances.hs view
@@ -0,0 +1,161 @@+{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.LinearAlgebra.Instances+Copyright   :  (c) Alberto Ruiz 2006+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  portable++This module exports Show, Eq, Num, Fractional, and Floating instances for Vector and Matrix.++In the context of the standard numeric operators, one-component vectors and matrices automatically expand to match the dimensions of the other operand.++-}+-----------------------------------------------------------------------------++module Numeric.LinearAlgebra.Instances(+) where++import Numeric.LinearAlgebra.Linear+import Numeric.GSL.Vector+import Data.Packed.Matrix+import Data.Packed.Vector+import Complex+import Data.List(transpose,intersperse)+import Foreign(Storable)++------------------------------------------------------------------++instance (Show a, Element a) => (Show (Matrix a)) where+    show m = (sizes++) . dsp . map (map show) . toLists $ m+        where sizes = "("++show (rows m)++"><"++show (cols m)++")\n"++dsp as = (++" ]") . (" ["++) . init . drop 2 . unlines . map (" , "++) . map unwords' $ transpose mtp+    where+        mt = transpose as+        longs = map (maximum . map length) mt+        mtp = zipWith (\a b -> map (pad a) b) longs mt+        pad n str = replicate (n - length str) ' ' ++ str+        unwords' = concat . intersperse ", "++instance (Show a, Storable a) => (Show (Vector a)) where+    show v = (show (dim v))++" |> " ++ show (toList v)++------------------------------------------------------------------++adaptScalar f1 f2 f3 x y+    | dim x == 1 = f1   (x@>0) y+    | dim y == 1 = f3 x (y@>0)+    | otherwise = f2 x y++liftMatrix2' :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t+liftMatrix2' f m1 m2 | compat' m1 m2 = reshape (max (cols m1) (cols m2)) (f (flatten m1) (flatten m2))+                     | otherwise    = error "nonconformant matrices in liftMatrix2'"++compat' :: Matrix a -> Matrix b -> Bool+compat' m1 m2 = rows m1 == 1 && cols m1 == 1+             || rows m2 == 1 && cols m2 == 1+             || rows m1 == rows m2 && cols m1 == cols m2++instance (Eq a, Element a) => Eq (Vector a) where+    a == b = dim a == dim b && toList a == toList b++instance (Linear Vector a) => Num (Vector a) where+    (+) = adaptScalar addConstant add (flip addConstant)+    negate = scale (-1)+    (*) = adaptScalar scale mul (flip scale)+    signum = liftVector signum+    abs = liftVector abs+    fromInteger = fromList . return . fromInteger++instance (Eq a, Element a) => Eq (Matrix a) where+    a == b = cols a == cols b && flatten a == flatten b++instance (Linear Vector a) => Num (Matrix a) where+    (+) = liftMatrix2' (+)+    (-) = liftMatrix2' (-)+    negate = liftMatrix negate+    (*) = liftMatrix2' (*)+    signum = liftMatrix signum+    abs = liftMatrix abs+    fromInteger = (1><1) . return . fromInteger++---------------------------------------------------++instance (Linear Vector a) => Fractional (Vector a) where+    fromRational n = fromList [fromRational n]+    (/) = adaptScalar f divide g where+        r `f` v = scaleRecip r v+        v `g` r = scale (recip r) v++-------------------------------------------------------++instance (Linear Vector a, Fractional (Vector a)) => Fractional (Matrix a) where+    fromRational n = (1><1) [fromRational n]+    (/) = liftMatrix2' (/)++---------------------------------------------------------++instance Floating (Vector Double) where+    sin   = vectorMapR Sin+    cos   = vectorMapR Cos+    tan   = vectorMapR Tan+    asin  = vectorMapR ASin+    acos  = vectorMapR ACos+    atan  = vectorMapR ATan+    sinh  = vectorMapR Sinh+    cosh  = vectorMapR Cosh+    tanh  = vectorMapR Tanh+    asinh = vectorMapR ASinh+    acosh = vectorMapR ACosh+    atanh = vectorMapR ATanh+    exp   = vectorMapR Exp+    log   = vectorMapR Log+    sqrt  = vectorMapR Sqrt+    (**)  = adaptScalar (vectorMapValR PowSV) (vectorZipR Pow) (flip (vectorMapValR PowVS))+    pi    = fromList [pi]++-------------------------------------------------------------++instance Floating (Vector (Complex Double)) where+    sin   = vectorMapC Sin+    cos   = vectorMapC Cos+    tan   = vectorMapC Tan+    asin  = vectorMapC ASin+    acos  = vectorMapC ACos+    atan  = vectorMapC ATan+    sinh  = vectorMapC Sinh+    cosh  = vectorMapC Cosh+    tanh  = vectorMapC Tanh+    asinh = vectorMapC ASinh+    acosh = vectorMapC ACosh+    atanh = vectorMapC ATanh+    exp   = vectorMapC Exp+    log   = vectorMapC Log+    sqrt  = vectorMapC Sqrt+    (**)  = adaptScalar (vectorMapValC PowSV) (vectorZipC Pow) (flip (vectorMapValC PowVS))+    pi    = fromList [pi]++-----------------------------------------------------------++instance (Linear Vector a, Floating (Vector a)) => Floating (Matrix a) where+    sin   = liftMatrix sin+    cos   = liftMatrix cos+    tan   = liftMatrix tan+    asin  = liftMatrix asin+    acos  = liftMatrix acos+    atan  = liftMatrix atan+    sinh  = liftMatrix sinh+    cosh  = liftMatrix cosh+    tanh  = liftMatrix tanh+    asinh = liftMatrix asinh+    acosh = liftMatrix acosh+    atanh = liftMatrix atanh+    exp   = liftMatrix exp+    log   = liftMatrix log+    (**)  = liftMatrix2' (**)+    sqrt  = liftMatrix sqrt+    pi    = (1><1) [pi]
+ lib/Numeric/LinearAlgebra/Interface.hs view
@@ -0,0 +1,106 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.LinearAlgebra.Interface+Copyright   :  (c) Alberto Ruiz 2007+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  portable++(Very provisional) operators for frequent operations.++-}+-----------------------------------------------------------------------------++module Numeric.LinearAlgebra.Interface(+    (<>),(<.>),+    (<\>),+    (.*),(*/),+    (<|>),(<->),+) where++import Numeric.LinearAlgebra.Linear+import Data.Packed.Vector+import Data.Packed.Matrix+import Numeric.LinearAlgebra.Algorithms++class Mul a b c | a b -> c where+ infixl 7 <>+ -- | matrix product+ (<>) :: Element t => a t -> b t -> c t++instance Mul Matrix Matrix Matrix where+    (<>) = multiply++instance Mul Matrix Vector Vector where+    (<>) m v = flatten $ m <> (asColumn v)++instance Mul Vector Matrix Vector where+    (<>) v m = flatten $ (asRow v) <> m++---------------------------------------------------++-- | @u \<.\> v = dot u v@+(<.>) :: (Element t) => Vector t -> Vector t -> t+infixl 7 <.>+(<.>) = dot++----------------------------------------------------++-- | @x .* a = scale x a@+(.*) :: (Linear c a) => a -> c a -> c a+infixl 7 .*+a .* x = scale a x++----------------------------------------------------++-- | @a *\/ x = scale (recip x) a@+(*/) :: (Linear c a) => c a -> a -> c a+infixl 7 */+v */ x = scale (recip x) v++-- | least squares solution of a linear system, similar to the \\ operator of Matlab\/Octave (based on linearSolveSVD).+(<\>) :: (Field a) => Matrix a -> Vector a -> Vector a+infixl 7 <\>+m <\> v = flatten (linearSolveSVD m (reshape 1 v))++------------------------------------------------++class Joinable a b where+    joinH :: Element t => a t -> b t -> Matrix t+    joinV :: Element t => a t -> b t -> Matrix t++instance Joinable Matrix Matrix where+    joinH m1 m2 = fromBlocks [[m1,m2]]+    joinV m1 m2 = fromBlocks [[m1],[m2]]++instance Joinable Matrix Vector where+    joinH m v = joinH m (asColumn v)+    joinV m v = joinV m (asRow v)++instance Joinable Vector Matrix where+    joinH v m = joinH (asColumn v) m+    joinV v m = joinV (asRow v) m++infixl 4 <|>+infixl 3 <->++{- | Horizontal concatenation of matrices and vectors:++@> (ident 3 \<-\> 3 * ident 3) \<|\> fromList [1..6.0]+(6><4)+ [ 1.0, 0.0, 0.0, 1.0+ , 0.0, 1.0, 0.0, 2.0+ , 0.0, 0.0, 1.0, 3.0+ , 3.0, 0.0, 0.0, 4.0+ , 0.0, 3.0, 0.0, 5.0+ , 0.0, 0.0, 3.0, 6.0 ]@+-}+(<|>) :: (Element t, Joinable a b) => a t -> b t -> Matrix t+a <|> b = joinH a b++-- | Vertical concatenation of matrices and vectors.+(<->) :: (Element t, Joinable a b) => a t -> b t -> Matrix t+a <-> b = joinV a b
+ lib/Numeric/LinearAlgebra/LAPACK.hs view
@@ -0,0 +1,320 @@+{-# OPTIONS_GHC #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Numeric.LinearAlgebra.LAPACK+-- Copyright   :  (c) Alberto Ruiz 2006-7+-- License     :  GPL-style+-- +-- Maintainer  :  Alberto Ruiz (aruiz at um dot es)+-- Stability   :  provisional+-- Portability :  portable (uses FFI)+--+-- Wrappers for a few LAPACK functions (<http://www.netlib.org/lapack>).+--+-----------------------------------------------------------------------------++module Numeric.LinearAlgebra.LAPACK (+    svdR, svdRdd, svdC,+    eigC, eigR, eigS, eigH, eigS', eigH',+    linearSolveR, linearSolveC,+    linearSolveLSR, linearSolveLSC,+    linearSolveSVDR, linearSolveSVDC,+    cholS, cholH,+    qrR, qrC,+    hessR, hessC,+    schurR, schurC+) where++import Data.Packed.Internal+import Data.Packed.Internal.Vector+import Data.Packed.Internal.Matrix+import Data.Packed.Vector+import Data.Packed.Matrix+import Numeric.GSL.Vector(vectorMapValR, FunCodeSV(Scale))+import Complex+import Foreign++-----------------------------------------------------------------------------+foreign import ccall "LAPACK/lapack-aux.h svd_l_R" dgesvd :: TMMVM+foreign import ccall "LAPACK/lapack-aux.h svd_l_C" zgesvd :: TCMCMVCM+foreign import ccall "LAPACK/lapack-aux.h svd_l_Rdd" dgesdd :: TMMVM++-- | Wrapper for LAPACK's /dgesvd/, which computes the full svd decomposition of a real matrix.+--+-- @(u,s,v)=full svdR m@ so that @m=u \<\> s \<\> 'trans' v@.+svdR :: Matrix Double -> (Matrix Double, Vector Double, Matrix Double)+svdR = svdAux dgesvd "svdR" . fmat++-- | Wrapper for LAPACK's /dgesvd/, which computes the full svd decomposition of a real matrix.+--+-- @(u,s,v)=full svdRdd m@ so that @m=u \<\> s \<\> 'trans' v@.+svdRdd :: Matrix Double -> (Matrix Double, Vector Double, Matrix Double)+svdRdd = svdAux dgesdd "svdRdd" . fmat++-- | Wrapper for LAPACK's /zgesvd/, which computes the full svd decomposition of a complex matrix.+--+-- @(u,s,v)=full svdC m@ so that @m=u \<\> comp s \<\> 'trans' v@.+svdC :: Matrix (Complex Double) -> (Matrix (Complex Double), Vector Double, Matrix (Complex Double))+svdC = svdAux zgesvd "svdC" . fmat++svdAux f st x = unsafePerformIO $ do+    u <- createMatrix ColumnMajor r r+    s <- createVector (min r c)+    v <- createMatrix ColumnMajor c c+    app4 f mat x mat u vec s mat v st+    return (u,s,trans v)+  where r = rows x+        c = cols x++-----------------------------------------------------------------------------+eigAux f st m+    | r == 1 = (fromList [flatten m `at` 0], singleton 1)+    | otherwise = unsafePerformIO $ do+        l <- createVector r+        v <- createMatrix ColumnMajor r r+        dummy <- createMatrix ColumnMajor 1 1+        app4 f mat m mat dummy vec l mat v st+        return (l,v)+  where r = rows m+++foreign import ccall "LAPACK/lapack-aux.h eig_l_C" zgeev :: TCMCMCVCM+foreign import ccall "LAPACK/lapack-aux.h eig_l_R" dgeev :: TMMCVM+foreign import ccall "LAPACK/lapack-aux.h eig_l_S" dsyev :: TMVM+foreign import ccall "LAPACK/lapack-aux.h eig_l_H" zheev :: TCMVCM++-- | Wrapper for LAPACK's /zgeev/, which computes the eigenvalues and right eigenvectors of a general complex matrix:+--+-- if @(l,v)=eigC m@ then @m \<\> v = v \<\> diag l@.+--+-- The eigenvectors are the columns of v.+-- The eigenvalues are not sorted.+eigC :: Matrix (Complex Double) -> (Vector (Complex Double), Matrix (Complex Double))+eigC = eigAux zgeev "eigC" . fmat++-----------------------------------------------------------------------------++-- | Wrapper for LAPACK's /dgeev/, which computes the eigenvalues and right eigenvectors of a general real matrix:+--+-- if @(l,v)=eigR m@ then @m \<\> v = v \<\> diag l@.+--+-- The eigenvectors are the columns of v.+-- The eigenvalues are not sorted.+eigR :: Matrix Double -> (Vector (Complex Double), Matrix (Complex Double))+eigR m = (s', v'')+    where (s,v) = eigRaux (fmat m)+          s' = toComplex (subVector 0 r (asReal s), subVector r r (asReal s))+          v' = toRows $ trans v+          v'' = fromColumns $ fixeig (toList s') v'+          r = rows m++eigRaux :: Matrix Double -> (Vector (Complex Double), Matrix Double)+eigRaux m+    | r == 1 = (fromList [(flatten m `at` 0):+0], singleton 1)+    | otherwise = unsafePerformIO $ do+        l <- createVector r+        v <- createMatrix ColumnMajor r r+        dummy <- createMatrix ColumnMajor 1 1+        app4 dgeev mat m mat dummy vec l mat v "eigR"+        return (l,v)+  where r = rows m++fixeig  []  _ =  []+fixeig [_] [v] = [comp v]+fixeig ((r1:+i1):(r2:+i2):r) (v1:v2:vs)+    | r1 == r2 && i1 == (-i2) = toComplex (v1,v2) : toComplex (v1,scale (-1) v2) : fixeig r vs+    | otherwise = comp v1 : fixeig ((r2:+i2):r) (v2:vs)+  where scale = vectorMapValR Scale+fixeig _ _ = error "fixeig with impossible inputs"++-----------------------------------------------------------------------------++-- | Wrapper for LAPACK's /dsyev/, which computes the eigenvalues and right eigenvectors of a symmetric real matrix:+--+-- if @(l,v)=eigSl m@ then @m \<\> v = v \<\> diag l@.+--+-- The eigenvectors are the columns of v.+-- The eigenvalues are sorted in descending order (use eigS' for ascending order).+eigS :: Matrix Double -> (Vector Double, Matrix Double)+eigS m = (s', fliprl v)+    where (s,v) = eigS' (fmat m)+          s' = fromList . reverse . toList $  s++eigS' m+    | r == 1 = (fromList [flatten m `at` 0], singleton 1)+    | otherwise = unsafePerformIO $ do+        l <- createVector r+        v <- createMatrix ColumnMajor r r+        app3 dsyev mat m vec l mat v "eigS"+        return (l,v)+  where r = rows m++-----------------------------------------------------------------------------++-- | Wrapper for LAPACK's /zheev/, which computes the eigenvalues and right eigenvectors of a hermitian complex matrix:+--+-- if @(l,v)=eigH m@ then @m \<\> s v = v \<\> diag l@.+--+-- The eigenvectors are the columns of v.+-- The eigenvalues are sorted in descending order (use eigH' for ascending order).+eigH :: Matrix (Complex Double) -> (Vector Double, Matrix (Complex Double))+eigH m = (s', fliprl v)+    where (s,v) = eigH' (fmat m)+          s' = fromList . reverse . toList $  s++eigH' m+    | r == 1 = (fromList [realPart (flatten m `at` 0)], singleton 1)+    | otherwise = unsafePerformIO $ do+        l <- createVector r+        v <- createMatrix ColumnMajor r r+        app3 zheev mat m vec l mat v "eigH"+        return (l,v)+  where r = rows m++-----------------------------------------------------------------------------+foreign import ccall "LAPACK/lapack-aux.h linearSolveR_l" dgesv :: TMMM+foreign import ccall "LAPACK/lapack-aux.h linearSolveC_l" zgesv :: TCMCMCM++linearSolveSQAux f st a b+    | n1==n2 && n1==r = unsafePerformIO $ do+        s <- createMatrix ColumnMajor r c+        app3 f mat a mat b mat s st+        return s+    | otherwise = error $ st ++ " of nonsquare matrix"+  where n1 = rows a+        n2 = cols a+        r  = rows b+        c  = cols b++-- | Wrapper for LAPACK's /dgesv/, which solves a general real linear system (for several right-hand sides) internally using the lu decomposition.+linearSolveR :: Matrix Double -> Matrix Double -> Matrix Double+linearSolveR a b = linearSolveSQAux dgesv "linearSolveR" (fmat a) (fmat b)++-- | Wrapper for LAPACK's /zgesv/, which solves a general complex linear system (for several right-hand sides) internally using the lu decomposition.+linearSolveC :: Matrix (Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)+linearSolveC a b = linearSolveSQAux zgesv "linearSolveC" (fmat a) (fmat b)++-----------------------------------------------------------------------------------+foreign import ccall "LAPACK/lapack-aux.h linearSolveLSR_l" dgels :: TMMM+foreign import ccall "LAPACK/lapack-aux.h linearSolveLSC_l" zgels :: TCMCMCM+foreign import ccall "LAPACK/lapack-aux.h linearSolveSVDR_l" dgelss :: Double -> TMMM+foreign import ccall "LAPACK/lapack-aux.h linearSolveSVDC_l" zgelss :: Double -> TCMCMCM++linearSolveAux f st a b = unsafePerformIO $ do+    r <- createMatrix ColumnMajor (max m n) nrhs+    app3 f mat a mat b mat r st+    return r+  where m = rows a+        n = cols a+        nrhs = cols b++-- | Wrapper for LAPACK's /dgels/, which obtains the least squared error solution of an overconstrained real linear system or the minimum norm solution of an underdetermined system, for several right-hand sides. For rank deficient systems use 'linearSolveSVDR'.+linearSolveLSR :: Matrix Double -> Matrix Double -> Matrix Double+linearSolveLSR a b = subMatrix (0,0) (cols a, cols b) $+                     linearSolveAux dgels "linearSolverLSR" (fmat a) (fmat b)++-- | Wrapper for LAPACK's /zgels/, which obtains the least squared error solution of an overconstrained complex linear system or the minimum norm solution of an underdetermined system, for several right-hand sides. For rank deficient systems use 'linearSolveSVDC'.+linearSolveLSC :: Matrix (Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)+linearSolveLSC a b = subMatrix (0,0) (cols a, cols b) $+                     linearSolveAux zgels "linearSolveLSC" (fmat a) (fmat b)++-- | Wrapper for LAPACK's /dgelss/, which obtains the minimum norm solution to a real linear least squares problem Ax=B using the svd, for several right-hand sides. Admits rank deficient systems but it is slower than 'linearSolveLSR'. The effective rank of A is determined by treating as zero those singular valures which are less than rcond times the largest singular value. If rcond == Nothing machine precision is used.+linearSolveSVDR :: Maybe Double   -- ^ rcond+                -> Matrix Double  -- ^ coefficient matrix+                -> Matrix Double  -- ^ right hand sides (as columns)+                -> Matrix Double  -- ^ solution vectors (as columns)+linearSolveSVDR (Just rcond) a b = subMatrix (0,0) (cols a, cols b) $+                                   linearSolveAux (dgelss rcond) "linearSolveSVDR" (fmat a) (fmat b)+linearSolveSVDR Nothing a b = linearSolveSVDR (Just (-1)) (fmat a) (fmat b)++-- | Wrapper for LAPACK's /zgelss/, which obtains the minimum norm solution to a complex linear least squares problem Ax=B using the svd, for several right-hand sides. Admits rank deficient systems but it is slower than 'linearSolveLSC'. The effective rank of A is determined by treating as zero those singular valures which are less than rcond times the largest singular value. If rcond == Nothing machine precision is used.+linearSolveSVDC :: Maybe Double            -- ^ rcond+                -> Matrix (Complex Double) -- ^ coefficient matrix+                -> Matrix (Complex Double) -- ^ right hand sides (as columns)+                -> Matrix (Complex Double) -- ^ solution vectors (as columns)+linearSolveSVDC (Just rcond) a b = subMatrix (0,0) (cols a, cols b) $+                                   linearSolveAux (zgelss rcond) "linearSolveSVDC" (fmat a) (fmat b)+linearSolveSVDC Nothing a b = linearSolveSVDC (Just (-1)) (fmat a) (fmat b)++-----------------------------------------------------------------------------------+foreign import ccall "LAPACK/lapack-aux.h chol_l_H" zpotrf :: TCMCM+foreign import ccall "LAPACK/lapack-aux.h chol_l_S" dpotrf :: TMM++-- | Wrapper for LAPACK's /zpotrf/, which computes the Cholesky factorization of a+-- complex Hermitian positive definite matrix.+cholH :: Matrix (Complex Double) -> Matrix (Complex Double)+cholH = cholAux zpotrf "cholH" . fmat++-- | Wrapper for LAPACK's /dpotrf/, which computes the Cholesky factorization of a+-- real symmetric positive definite matrix.+cholS :: Matrix Double -> Matrix Double+cholS = cholAux dpotrf "cholS" . fmat++cholAux f st a = unsafePerformIO $ do+    r <- createMatrix ColumnMajor n n+    app2 f mat a mat r st+    return r+  where n = rows a++-----------------------------------------------------------------------------------+foreign import ccall "LAPACK/lapack-aux.h qr_l_R" dgeqr2 :: TMVM+foreign import ccall "LAPACK/lapack-aux.h qr_l_C" zgeqr2 :: TCMCVCM++-- | Wrapper for LAPACK's /dgeqr2/, which computes a QR factorization of a real matrix.+qrR :: Matrix Double -> (Matrix Double, Vector Double)+qrR = qrAux dgeqr2 "qrR" . fmat++-- | Wrapper for LAPACK's /zgeqr2/, which computes a QR factorization of a complex matrix.+qrC :: Matrix (Complex Double) -> (Matrix (Complex Double), Vector (Complex Double))+qrC = qrAux zgeqr2 "qrC" . fmat++qrAux f st a = unsafePerformIO $ do+    r <- createMatrix ColumnMajor m n+    tau <- createVector mn+    app3 f mat a vec tau mat r st+    return (r,tau)+  where m = rows a+        n = cols a+        mn = min m n++-----------------------------------------------------------------------------------+foreign import ccall "LAPACK/lapack-aux.h hess_l_R" dgehrd :: TMVM+foreign import ccall "LAPACK/lapack-aux.h hess_l_C" zgehrd :: TCMCVCM++-- | Wrapper for LAPACK's /dgehrd/, which computes a Hessenberg factorization of a square real matrix.+hessR :: Matrix Double -> (Matrix Double, Vector Double)+hessR = hessAux dgehrd "hessR" . fmat++-- | Wrapper for LAPACK's /zgehrd/, which computes a Hessenberg factorization of a square complex matrix.+hessC :: Matrix (Complex Double) -> (Matrix (Complex Double), Vector (Complex Double))+hessC = hessAux zgehrd "hessC" . fmat++hessAux f st a = unsafePerformIO $ do+    r <- createMatrix ColumnMajor m n+    tau <- createVector (mn-1)+    app3 f mat a vec tau mat r st+    return (r,tau)+  where m = rows a+        n = cols a+        mn = min m n++-----------------------------------------------------------------------------------+foreign import ccall safe "LAPACK/lapack-aux.h schur_l_R" dgees :: TMMM+foreign import ccall "LAPACK/lapack-aux.h schur_l_C" zgees :: TCMCMCM++-- | Wrapper for LAPACK's /dgees/, which computes a Schur factorization of a square real matrix.+schurR :: Matrix Double -> (Matrix Double, Matrix Double)+schurR = schurAux dgees "schurR" . fmat++-- | Wrapper for LAPACK's /zgees/, which computes a Schur factorization of a square complex matrix.+schurC :: Matrix (Complex Double) -> (Matrix (Complex Double), Matrix (Complex Double))+schurC = schurAux zgees "schurC" . fmat++schurAux f st a = unsafePerformIO $ do+    u <- createMatrix ColumnMajor n n+    s <- createMatrix ColumnMajor n n+    app3 f mat a mat u mat s st+    return (u,s)+  where n = rows a++-----------------------------------------------------------------------------------
+ lib/Numeric/LinearAlgebra/LAPACK/clapack.h view
@@ -0,0 +1,5079 @@+#ifndef __CLAPACK_H+#define __CLAPACK_H+ +/* Subroutine */ int cbdsqr_(char *uplo, integer *n, integer *ncvt, integer *+	nru, integer *ncc, real *d__, real *e, complex *vt, integer *ldvt, +	complex *u, integer *ldu, complex *c__, integer *ldc, real *rwork, +	integer *info);+ +/* Subroutine */ int cgbbrd_(char *vect, integer *m, integer *n, integer *ncc,+	 integer *kl, integer *ku, complex *ab, integer *ldab, real *d__, +	real *e, complex *q, integer *ldq, complex *pt, integer *ldpt, +	complex *c__, integer *ldc, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgbcon_(char *norm, integer *n, integer *kl, integer *ku,+	 complex *ab, integer *ldab, integer *ipiv, real *anorm, real *rcond, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgbequ_(integer *m, integer *n, integer *kl, integer *ku,+	 complex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real +	*colcnd, real *amax, integer *info);+ +/* Subroutine */ int cgbrfs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, complex *ab, integer *ldab, complex *afb, integer *+	ldafb, integer *ipiv, complex *b, integer *ldb, complex *x, integer *+	ldx, real *ferr, real *berr, complex *work, real *rwork, integer *+	info);+ +/* Subroutine */ int cgbsv_(integer *n, integer *kl, integer *ku, integer *+	nrhs, complex *ab, integer *ldab, integer *ipiv, complex *b, integer *+	ldb, integer *info);+ +/* Subroutine */ int cgbsvx_(char *fact, char *trans, integer *n, integer *kl,+	 integer *ku, integer *nrhs, complex *ab, integer *ldab, complex *afb,+	 integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, +	complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real +	*ferr, real *berr, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgbtf2_(integer *m, integer *n, integer *kl, integer *ku,+	 complex *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int cgbtrf_(integer *m, integer *n, integer *kl, integer *ku,+	 complex *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int cgbtrs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, complex *ab, integer *ldab, integer *ipiv, complex +	*b, integer *ldb, integer *info);+ +/* Subroutine */ int cgebak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, real *scale, integer *m, complex *v, integer *ldv, +	integer *info);+ +/* Subroutine */ int cgebal_(char *job, integer *n, complex *a, integer *lda, +	integer *ilo, integer *ihi, real *scale, integer *info);+ +/* Subroutine */ int cgebd2_(integer *m, integer *n, complex *a, integer *lda,+	 real *d__, real *e, complex *tauq, complex *taup, complex *work, +	integer *info);+ +/* Subroutine */ int cgebrd_(integer *m, integer *n, complex *a, integer *lda,+	 real *d__, real *e, complex *tauq, complex *taup, complex *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int cgecon_(char *norm, integer *n, complex *a, integer *lda,+	 real *anorm, real *rcond, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgeequ_(integer *m, integer *n, complex *a, integer *lda,+	 real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, +	integer *info);+ +/* Subroutine */ int cgees_(char *jobvs, char *sort, L_fp select, integer *n, +	complex *a, integer *lda, integer *sdim, complex *w, complex *vs, +	integer *ldvs, complex *work, integer *lwork, real *rwork, logical *+	bwork, integer *info);+ +/* Subroutine */ int cgeesx_(char *jobvs, char *sort, L_fp select, char *+	sense, integer *n, complex *a, integer *lda, integer *sdim, complex *+	w, complex *vs, integer *ldvs, real *rconde, real *rcondv, complex *+	work, integer *lwork, real *rwork, logical *bwork, integer *info);+ +/* Subroutine */ int cgeev_(char *jobvl, char *jobvr, integer *n, complex *a, +	integer *lda, complex *w, complex *vl, integer *ldvl, complex *vr, +	integer *ldvr, complex *work, integer *lwork, real *rwork, integer *+	info);+ +/* Subroutine */ int cgeevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, complex *a, integer *lda, complex *w, complex *vl, +	integer *ldvl, complex *vr, integer *ldvr, integer *ilo, integer *ihi,+	 real *scale, real *abnrm, real *rconde, real *rcondv, complex *work, +	integer *lwork, real *rwork, integer *info);+ +/* Subroutine */ int cgegs_(char *jobvsl, char *jobvsr, integer *n, complex *+	a, integer *lda, complex *b, integer *ldb, complex *alpha, complex *+	beta, complex *vsl, integer *ldvsl, complex *vsr, integer *ldvsr, +	complex *work, integer *lwork, real *rwork, integer *info);+ +/* Subroutine */ int cgegv_(char *jobvl, char *jobvr, integer *n, complex *a, +	integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta,+	 complex *vl, integer *ldvl, complex *vr, integer *ldvr, complex *+	work, integer *lwork, real *rwork, integer *info);+ +/* Subroutine */ int cgehd2_(integer *n, integer *ilo, integer *ihi, complex *+	a, integer *lda, complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cgehrd_(integer *n, integer *ilo, integer *ihi, complex *+	a, integer *lda, complex *tau, complex *work, integer *lwork, integer +	*info);+ +/* Subroutine */ int cgelq2_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cgelqf_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cgels_(char *trans, integer *m, integer *n, integer *+	nrhs, complex *a, integer *lda, complex *b, integer *ldb, complex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int cgelsx_(integer *m, integer *n, integer *nrhs, complex *+	a, integer *lda, complex *b, integer *ldb, integer *jpvt, real *rcond,+	 integer *rank, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgelsy_(integer *m, integer *n, integer *nrhs, complex *+	a, integer *lda, complex *b, integer *ldb, integer *jpvt, real *rcond,+	 integer *rank, complex *work, integer *lwork, real *rwork, integer *+	info);+ +/* Subroutine */ int cgeql2_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cgeqlf_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cgeqp3_(integer *m, integer *n, complex *a, integer *lda,+	 integer *jpvt, complex *tau, complex *work, integer *lwork, real *+	rwork, integer *info);+ +/* Subroutine */ int cgeqpf_(integer *m, integer *n, complex *a, integer *lda,+	 integer *jpvt, complex *tau, complex *work, real *rwork, integer *+	info);+ +/* Subroutine */ int cgeqr2_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cgeqrf_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cgerfs_(char *trans, integer *n, integer *nrhs, complex *+	a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *+	b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgerq2_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cgerqf_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cgesc2_(integer *n, complex *a, integer *lda, complex *+	rhs, integer *ipiv, integer *jpiv, real *scale);+ +/* Subroutine */ int cgesv_(integer *n, integer *nrhs, complex *a, integer *+	lda, integer *ipiv, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cgesvx_(char *fact, char *trans, integer *n, integer *+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *+	ipiv, char *equed, real *r__, real *c__, complex *b, integer *ldb, +	complex *x, integer *ldx, real *rcond, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgetc2_(integer *n, complex *a, integer *lda, integer *+	ipiv, integer *jpiv, integer *info);+ +/* Subroutine */ int cgetf2_(integer *m, integer *n, complex *a, integer *lda,+	 integer *ipiv, integer *info);+ +/* Subroutine */ int cgetrf_(integer *m, integer *n, complex *a, integer *lda,+	 integer *ipiv, integer *info);+ +/* Subroutine */ int cgetri_(integer *n, complex *a, integer *lda, integer *+	ipiv, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cgetrs_(char *trans, integer *n, integer *nrhs, complex *+	a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int cggbak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, real *lscale, real *rscale, integer *m, complex *v, +	integer *ldv, integer *info);+ +/* Subroutine */ int cggbal_(char *job, integer *n, complex *a, integer *lda, +	complex *b, integer *ldb, integer *ilo, integer *ihi, real *lscale, +	real *rscale, real *work, integer *info);+ +/* Subroutine */ int cgges_(char *jobvsl, char *jobvsr, char *sort, L_fp +	selctg, integer *n, complex *a, integer *lda, complex *b, integer *+	ldb, integer *sdim, complex *alpha, complex *beta, complex *vsl, +	integer *ldvsl, complex *vsr, integer *ldvsr, complex *work, integer *+	lwork, real *rwork, logical *bwork, integer *info);+ +/* Subroutine */ int cggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp +	selctg, char *sense, integer *n, complex *a, integer *lda, complex *b,+	 integer *ldb, integer *sdim, complex *alpha, complex *beta, complex *+	vsl, integer *ldvsl, complex *vsr, integer *ldvsr, real *rconde, real +	*rcondv, complex *work, integer *lwork, real *rwork, integer *iwork, +	integer *liwork, logical *bwork, integer *info);+ +/* Subroutine */ int cggev_(char *jobvl, char *jobvr, integer *n, complex *a, +	integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta,+	 complex *vl, integer *ldvl, complex *vr, integer *ldvr, complex *+	work, integer *lwork, real *rwork, integer *info);+ +/* Subroutine */ int cggevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, complex *a, integer *lda, complex *b, integer *ldb,+	 complex *alpha, complex *beta, complex *vl, integer *ldvl, complex *+	vr, integer *ldvr, integer *ilo, integer *ihi, real *lscale, real *+	rscale, real *abnrm, real *bbnrm, real *rconde, real *rcondv, complex +	*work, integer *lwork, real *rwork, integer *iwork, logical *bwork, +	integer *info);+ +/* Subroutine */ int cggglm_(integer *n, integer *m, integer *p, complex *a, +	integer *lda, complex *b, integer *ldb, complex *d__, complex *x, +	complex *y, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cgghrd_(char *compq, char *compz, integer *n, integer *+	ilo, integer *ihi, complex *a, integer *lda, complex *b, integer *ldb,+	 complex *q, integer *ldq, complex *z__, integer *ldz, integer *info);+ +/* Subroutine */ int cgglse_(integer *m, integer *n, integer *p, complex *a, +	integer *lda, complex *b, integer *ldb, complex *c__, complex *d__, +	complex *x, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cggqrf_(integer *n, integer *m, integer *p, complex *a, +	integer *lda, complex *taua, complex *b, integer *ldb, complex *taub, +	complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cggrqf_(integer *m, integer *p, integer *n, complex *a, +	integer *lda, complex *taua, complex *b, integer *ldb, complex *taub, +	complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cggsvd_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *n, integer *p, integer *k, integer *l, complex *a, integer *+	lda, complex *b, integer *ldb, real *alpha, real *beta, complex *u, +	integer *ldu, complex *v, integer *ldv, complex *q, integer *ldq, +	complex *work, real *rwork, integer *iwork, integer *info);+ +/* Subroutine */ int cggsvp_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, complex *a, integer *lda, complex *b, integer +	*ldb, real *tola, real *tolb, integer *k, integer *l, complex *u, +	integer *ldu, complex *v, integer *ldv, complex *q, integer *ldq, +	integer *iwork, real *rwork, complex *tau, complex *work, integer *+	info);+ +/* Subroutine */ int cgtcon_(char *norm, integer *n, complex *dl, complex *+	d__, complex *du, complex *du2, integer *ipiv, real *anorm, real *+	rcond, complex *work, integer *info);+ +/* Subroutine */ int cgtrfs_(char *trans, integer *n, integer *nrhs, complex *+	dl, complex *d__, complex *du, complex *dlf, complex *df, complex *+	duf, complex *du2, integer *ipiv, complex *b, integer *ldb, complex *+	x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int cgtsv_(integer *n, integer *nrhs, complex *dl, complex *+	d__, complex *du, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cgtsvx_(char *fact, char *trans, integer *n, integer *+	nrhs, complex *dl, complex *d__, complex *du, complex *dlf, complex *+	df, complex *duf, complex *du2, integer *ipiv, complex *b, integer *+	ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cgttrf_(integer *n, complex *dl, complex *d__, complex *+	du, complex *du2, integer *ipiv, integer *info);+ +/* Subroutine */ int cgttrs_(char *trans, integer *n, integer *nrhs, complex *+	dl, complex *d__, complex *du, complex *du2, integer *ipiv, complex *+	b, integer *ldb, integer *info);+ +/* Subroutine */ int cgtts2_(integer *itrans, integer *n, integer *nrhs, +	complex *dl, complex *d__, complex *du, complex *du2, integer *ipiv, +	complex *b, integer *ldb);+ +/* Subroutine */ int chbev_(char *jobz, char *uplo, integer *n, integer *kd, +	complex *ab, integer *ldab, real *w, complex *z__, integer *ldz, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int chbevd_(char *jobz, char *uplo, integer *n, integer *kd, +	complex *ab, integer *ldab, real *w, complex *z__, integer *ldz, +	complex *work, integer *lwork, real *rwork, integer *lrwork, integer *+	iwork, integer *liwork, integer *info);+ +/* Subroutine */ int chbevx_(char *jobz, char *range, char *uplo, integer *n, +	integer *kd, complex *ab, integer *ldab, complex *q, integer *ldq, +	real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *+	m, real *w, complex *z__, integer *ldz, complex *work, real *rwork, +	integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int chbgst_(char *vect, char *uplo, integer *n, integer *ka, +	integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, +	complex *x, integer *ldx, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int chbgv_(char *jobz, char *uplo, integer *n, integer *ka, +	integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, +	real *w, complex *z__, integer *ldz, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int chbgvx_(char *jobz, char *range, char *uplo, integer *n, +	integer *ka, integer *kb, complex *ab, integer *ldab, complex *bb, +	integer *ldbb, complex *q, integer *ldq, real *vl, real *vu, integer *+	il, integer *iu, real *abstol, integer *m, real *w, complex *z__, +	integer *ldz, complex *work, real *rwork, integer *iwork, integer *+	ifail, integer *info);+ +/* Subroutine */ int chbtrd_(char *vect, char *uplo, integer *n, integer *kd, +	complex *ab, integer *ldab, real *d__, real *e, complex *q, integer *+	ldq, complex *work, integer *info);+ +/* Subroutine */ int checon_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, real *anorm, real *rcond, complex *work, integer *+	info);+ +/* Subroutine */ int cheev_(char *jobz, char *uplo, integer *n, complex *a, +	integer *lda, real *w, complex *work, integer *lwork, real *rwork, +	integer *info);+ +/* Subroutine */ int cheevd_(char *jobz, char *uplo, integer *n, complex *a, +	integer *lda, real *w, complex *work, integer *lwork, real *rwork, +	integer *lrwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int cheevr_(char *jobz, char *range, char *uplo, integer *n, +	complex *a, integer *lda, real *vl, real *vu, integer *il, integer *+	iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, +	integer *isuppz, complex *work, integer *lwork, real *rwork, integer *+	lrwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int cheevx_(char *jobz, char *range, char *uplo, integer *n, +	complex *a, integer *lda, real *vl, real *vu, integer *il, integer *+	iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, +	complex *work, integer *lwork, real *rwork, integer *iwork, integer *+	ifail, integer *info);+ +/* Subroutine */ int chegs2_(integer *itype, char *uplo, integer *n, complex *+	a, integer *lda, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int chegst_(integer *itype, char *uplo, integer *n, complex *+	a, integer *lda, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int chegv_(integer *itype, char *jobz, char *uplo, integer *+	n, complex *a, integer *lda, complex *b, integer *ldb, real *w, +	complex *work, integer *lwork, real *rwork, integer *info);+ +/* Subroutine */ int chegvd_(integer *itype, char *jobz, char *uplo, integer *+	n, complex *a, integer *lda, complex *b, integer *ldb, real *w, +	complex *work, integer *lwork, real *rwork, integer *lrwork, integer *+	iwork, integer *liwork, integer *info);+ +/* Subroutine */ int chegvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, complex *a, integer *lda, complex *b, integer *ldb, +	real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *+	m, real *w, complex *z__, integer *ldz, complex *work, integer *lwork,+	 real *rwork, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int cherfs_(char *uplo, integer *n, integer *nrhs, complex *+	a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *+	b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int chesv_(char *uplo, integer *n, integer *nrhs, complex *a,+	 integer *lda, integer *ipiv, complex *b, integer *ldb, complex *work,+	 integer *lwork, integer *info);+ +/* Subroutine */ int chesvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *+	ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond,+	 real *ferr, real *berr, complex *work, integer *lwork, real *rwork, +	integer *info);+ +/* Subroutine */ int chetf2_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, integer *info);+ +/* Subroutine */ int chetrd_(char *uplo, integer *n, complex *a, integer *lda,+	 real *d__, real *e, complex *tau, complex *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int chetrf_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int chetri_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, complex *work, integer *info);+ +/* Subroutine */ int chetrs_(char *uplo, integer *n, integer *nrhs, complex *+	a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int chgeqz_(char *job, char *compq, char *compz, integer *n, +	integer *ilo, integer *ihi, complex *a, integer *lda, complex *b, +	integer *ldb, complex *alpha, complex *beta, complex *q, integer *ldq,+	 complex *z__, integer *ldz, complex *work, integer *lwork, real *+	rwork, integer *info);+ +/* Subroutine */ int chpcon_(char *uplo, integer *n, complex *ap, integer *+	ipiv, real *anorm, real *rcond, complex *work, integer *info);+ +/* Subroutine */ int chpev_(char *jobz, char *uplo, integer *n, complex *ap, +	real *w, complex *z__, integer *ldz, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int chpevd_(char *jobz, char *uplo, integer *n, complex *ap, +	real *w, complex *z__, integer *ldz, complex *work, integer *lwork, +	real *rwork, integer *lrwork, integer *iwork, integer *liwork, +	integer *info);+ +/* Subroutine */ int chpevx_(char *jobz, char *range, char *uplo, integer *n, +	complex *ap, real *vl, real *vu, integer *il, integer *iu, real *+	abstol, integer *m, real *w, complex *z__, integer *ldz, complex *+	work, real *rwork, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int chpgst_(integer *itype, char *uplo, integer *n, complex *+	ap, complex *bp, integer *info);+ +/* Subroutine */ int chpgv_(integer *itype, char *jobz, char *uplo, integer *+	n, complex *ap, complex *bp, real *w, complex *z__, integer *ldz, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int chpgvd_(integer *itype, char *jobz, char *uplo, integer *+	n, complex *ap, complex *bp, real *w, complex *z__, integer *ldz, +	complex *work, integer *lwork, real *rwork, integer *lrwork, integer *+	iwork, integer *liwork, integer *info);+ +/* Subroutine */ int chpgvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, complex *ap, complex *bp, real *vl, real *vu, +	integer *il, integer *iu, real *abstol, integer *m, real *w, complex *+	z__, integer *ldz, complex *work, real *rwork, integer *iwork, +	integer *ifail, integer *info);+ +/* Subroutine */ int chprfs_(char *uplo, integer *n, integer *nrhs, complex *+	ap, complex *afp, integer *ipiv, complex *b, integer *ldb, complex *x,+	 integer *ldx, real *ferr, real *berr, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int chpsv_(char *uplo, integer *n, integer *nrhs, complex *+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int chpsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, complex *ap, complex *afp, integer *ipiv, complex *b, integer *+	ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int chptrd_(char *uplo, integer *n, complex *ap, real *d__, +	real *e, complex *tau, integer *info);+ +/* Subroutine */ int chptrf_(char *uplo, integer *n, complex *ap, integer *+	ipiv, integer *info);+ +/* Subroutine */ int chptri_(char *uplo, integer *n, complex *ap, integer *+	ipiv, complex *work, integer *info);+ +/* Subroutine */ int chptrs_(char *uplo, integer *n, integer *nrhs, complex *+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int chsein_(char *side, char *eigsrc, char *initv, logical *+	select, integer *n, complex *h__, integer *ldh, complex *w, complex *+	vl, integer *ldvl, complex *vr, integer *ldvr, integer *mm, integer *+	m, complex *work, real *rwork, integer *ifaill, integer *ifailr, +	integer *info);+ +/* Subroutine */ int chseqr_(char *job, char *compz, integer *n, integer *ilo,+	 integer *ihi, complex *h__, integer *ldh, complex *w, complex *z__, +	integer *ldz, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int clabrd_(integer *m, integer *n, integer *nb, complex *a, +	integer *lda, real *d__, real *e, complex *tauq, complex *taup, +	complex *x, integer *ldx, complex *y, integer *ldy);+ +/* Subroutine */ int clacgv_(integer *n, complex *x, integer *incx);+ +/* Subroutine */ int clacon_(integer *n, complex *v, complex *x, real *est, +	integer *kase);+ +/* Subroutine */ int clacp2_(char *uplo, integer *m, integer *n, real *a, +	integer *lda, complex *b, integer *ldb);+ +/* Subroutine */ int clacpy_(char *uplo, integer *m, integer *n, complex *a, +	integer *lda, complex *b, integer *ldb);+ +/* Subroutine */ int clacrm_(integer *m, integer *n, complex *a, integer *lda,+	 real *b, integer *ldb, complex *c__, integer *ldc, real *rwork);+ +/* Subroutine */ int clacrt_(integer *n, complex *cx, integer *incx, complex *+	cy, integer *incy, complex *c__, complex *s);+ +/* Subroutine */ int claed0_(integer *qsiz, integer *n, real *d__, real *e, +	complex *q, integer *ldq, complex *qstore, integer *ldqs, real *rwork,+	 integer *iwork, integer *info);+ +/* Subroutine */ int claed7_(integer *n, integer *cutpnt, integer *qsiz, +	integer *tlvls, integer *curlvl, integer *curpbm, real *d__, complex *+	q, integer *ldq, real *rho, integer *indxq, real *qstore, integer *+	qptr, integer *prmptr, integer *perm, integer *givptr, integer *+	givcol, real *givnum, complex *work, real *rwork, integer *iwork, +	integer *info);+ +/* Subroutine */ int claed8_(integer *k, integer *n, integer *qsiz, complex *+	q, integer *ldq, real *d__, real *rho, integer *cutpnt, real *z__, +	real *dlamda, complex *q2, integer *ldq2, real *w, integer *indxp, +	integer *indx, integer *indxq, integer *perm, integer *givptr, +	integer *givcol, real *givnum, integer *info);+ +/* Subroutine */ int claein_(logical *rightv, logical *noinit, integer *n, +	complex *h__, integer *ldh, complex *w, complex *v, complex *b, +	integer *ldb, real *rwork, real *eps3, real *smlnum, integer *info);+ +/* Subroutine */ int claesy_(complex *a, complex *b, complex *c__, complex *+	rt1, complex *rt2, complex *evscal, complex *cs1, complex *sn1);+ +/* Subroutine */ int claev2_(complex *a, complex *b, complex *c__, real *rt1, +	real *rt2, real *cs1, complex *sn1);+ +/* Subroutine */ int clags2_(logical *upper, real *a1, complex *a2, real *a3, +	real *b1, complex *b2, real *b3, real *csu, complex *snu, real *csv, +	complex *snv, real *csq, complex *snq);+ +/* Subroutine */ int clagtm_(char *trans, integer *n, integer *nrhs, real *+	alpha, complex *dl, complex *d__, complex *du, complex *x, integer *+	ldx, real *beta, complex *b, integer *ldb);+ +/* Subroutine */ int clahef_(char *uplo, integer *n, integer *nb, integer *kb,+	 complex *a, integer *lda, integer *ipiv, complex *w, integer *ldw, +	integer *info);+ +/* Subroutine */ int clahqr_(logical *wantt, logical *wantz, integer *n, +	integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, +	integer *iloz, integer *ihiz, complex *z__, integer *ldz, integer *+	info);+ +/* Subroutine */ int clahrd_(integer *n, integer *k, integer *nb, complex *a, +	integer *lda, complex *tau, complex *t, integer *ldt, complex *y, +	integer *ldy);+ +/* Subroutine */ int claic1_(integer *job, integer *j, complex *x, real *sest,+	 complex *w, complex *gamma, real *sestpr, complex *s, complex *c__);+ +/* Subroutine */ int clals0_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, integer *nrhs, complex *b, integer *ldb, complex *bx, +	integer *ldbx, integer *perm, integer *givptr, integer *givcol, +	integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real *+	difl, real *difr, real *z__, integer *k, real *c__, real *s, real *+	rwork, integer *info);+ +/* Subroutine */ int clalsa_(integer *icompq, integer *smlsiz, integer *n, +	integer *nrhs, complex *b, integer *ldb, complex *bx, integer *ldbx, +	real *u, integer *ldu, real *vt, integer *k, real *difl, real *difr, +	real *z__, real *poles, integer *givptr, integer *givcol, integer *+	ldgcol, integer *perm, real *givnum, real *c__, real *s, real *rwork, +	integer *iwork, integer *info);+ +/* Subroutine */ int clapll_(integer *n, complex *x, integer *incx, complex *+	y, integer *incy, real *ssmin);+ +/* Subroutine */ int clapmt_(logical *forwrd, integer *m, integer *n, complex +	*x, integer *ldx, integer *k);+ +/* Subroutine */ int claqgb_(integer *m, integer *n, integer *kl, integer *ku,+	 complex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real +	*colcnd, real *amax, char *equed);+ +/* Subroutine */ int claqge_(integer *m, integer *n, complex *a, integer *lda,+	 real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char *+	equed);+ +/* Subroutine */ int claqhb_(char *uplo, integer *n, integer *kd, complex *ab,+	 integer *ldab, real *s, real *scond, real *amax, char *equed);+ +/* Subroutine */ int claqhe_(char *uplo, integer *n, complex *a, integer *lda,+	 real *s, real *scond, real *amax, char *equed);+ +/* Subroutine */ int claqhp_(char *uplo, integer *n, complex *ap, real *s, +	real *scond, real *amax, char *equed);+ +/* Subroutine */ int claqp2_(integer *m, integer *n, integer *offset, complex +	*a, integer *lda, integer *jpvt, complex *tau, real *vn1, real *vn2, +	complex *work);+ +/* Subroutine */ int claqps_(integer *m, integer *n, integer *offset, integer +	*nb, integer *kb, complex *a, integer *lda, integer *jpvt, complex *+	tau, real *vn1, real *vn2, complex *auxv, complex *f, integer *ldf);+ +/* Subroutine */ int claqsb_(char *uplo, integer *n, integer *kd, complex *ab,+	 integer *ldab, real *s, real *scond, real *amax, char *equed);+ +/* Subroutine */ int claqsp_(char *uplo, integer *n, complex *ap, real *s, +	real *scond, real *amax, char *equed);+ +/* Subroutine */ int claqsy_(char *uplo, integer *n, complex *a, integer *lda,+	 real *s, real *scond, real *amax, char *equed);+ +/* Subroutine */ int clar1v_(integer *n, integer *b1, integer *bn, real *+	sigma, real *d__, real *l, real *ld, real *lld, real *gersch, complex +	*z__, real *ztz, real *mingma, integer *r__, integer *isuppz, real *+	work);+ +/* Subroutine */ int clar2v_(integer *n, complex *x, complex *y, complex *z__,+	 integer *incx, real *c__, complex *s, integer *incc);+ +/* Subroutine */ int clarcm_(integer *m, integer *n, real *a, integer *lda, +	complex *b, integer *ldb, complex *c__, integer *ldc, real *rwork);+ +/* Subroutine */ int clarf_(char *side, integer *m, integer *n, complex *v, +	integer *incv, complex *tau, complex *c__, integer *ldc, complex *+	work);+ +/* Subroutine */ int clarfb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, complex *v, integer *ldv, +	complex *t, integer *ldt, complex *c__, integer *ldc, complex *work, +	integer *ldwork);+ +/* Subroutine */ int clarfg_(integer *n, complex *alpha, complex *x, integer *+	incx, complex *tau);+ +/* Subroutine */ int clarft_(char *direct, char *storev, integer *n, integer *+	k, complex *v, integer *ldv, complex *tau, complex *t, integer *ldt);+ +/* Subroutine */ int clarfx_(char *side, integer *m, integer *n, complex *v, +	complex *tau, complex *c__, integer *ldc, complex *work);+ +/* Subroutine */ int clargv_(integer *n, complex *x, integer *incx, complex *+	y, integer *incy, real *c__, integer *incc);+ +/* Subroutine */ int clarnv_(integer *idist, integer *iseed, integer *n, +	complex *x);+ +/* Subroutine */ int clarrv_(integer *n, real *d__, real *l, integer *isplit, +	integer *m, real *w, integer *iblock, real *gersch, real *tol, +	complex *z__, integer *ldz, integer *isuppz, real *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int clartg_(complex *f, complex *g, real *cs, complex *sn, +	complex *r__);+ +/* Subroutine */ int clartv_(integer *n, complex *x, integer *incx, complex *+	y, integer *incy, real *c__, complex *s, integer *incc);+ +/* Subroutine */ int clarz_(char *side, integer *m, integer *n, integer *l, +	complex *v, integer *incv, complex *tau, complex *c__, integer *ldc, +	complex *work);+ +/* Subroutine */ int clarzb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, integer *l, complex *v, +	integer *ldv, complex *t, integer *ldt, complex *c__, integer *ldc, +	complex *work, integer *ldwork);+ +/* Subroutine */ int clarzt_(char *direct, char *storev, integer *n, integer *+	k, complex *v, integer *ldv, complex *tau, complex *t, integer *ldt);+ +/* Subroutine */ int clascl_(char *type__, integer *kl, integer *ku, real *+	cfrom, real *cto, integer *m, integer *n, complex *a, integer *lda, +	integer *info);+ +/* Subroutine */ int claset_(char *uplo, integer *m, integer *n, complex *+	alpha, complex *beta, complex *a, integer *lda);+ +/* Subroutine */ int clasr_(char *side, char *pivot, char *direct, integer *m,+	 integer *n, real *c__, real *s, complex *a, integer *lda);+ +/* Subroutine */ int classq_(integer *n, complex *x, integer *incx, real *+	scale, real *sumsq);+ +/* Subroutine */ int claswp_(integer *n, complex *a, integer *lda, integer *+	k1, integer *k2, integer *ipiv, integer *incx);+ +/* Subroutine */ int clasyf_(char *uplo, integer *n, integer *nb, integer *kb,+	 complex *a, integer *lda, integer *ipiv, complex *w, integer *ldw, +	integer *info);+ +/* Subroutine */ int clatbs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, integer *kd, complex *ab, integer *ldab, complex *+	x, real *scale, real *cnorm, integer *info);+ +/* Subroutine */ int clatdf_(integer *ijob, integer *n, complex *z__, integer +	*ldz, complex *rhs, real *rdsum, real *rdscal, integer *ipiv, integer +	*jpiv);+ +/* Subroutine */ int clatps_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, complex *ap, complex *x, real *scale, real *cnorm,+	 integer *info);+ +/* Subroutine */ int clatrd_(char *uplo, integer *n, integer *nb, complex *a, +	integer *lda, real *e, complex *tau, complex *w, integer *ldw);+ +/* Subroutine */ int clatrs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, complex *a, integer *lda, complex *x, real *scale,+	 real *cnorm, integer *info);+ +/* Subroutine */ int clatrz_(integer *m, integer *n, integer *l, complex *a, +	integer *lda, complex *tau, complex *work);+ +/* Subroutine */ int clatzm_(char *side, integer *m, integer *n, complex *v, +	integer *incv, complex *tau, complex *c1, complex *c2, integer *ldc, +	complex *work);+ +/* Subroutine */ int clauu2_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *info);+ +/* Subroutine */ int clauum_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *info);+ +/* Subroutine */ int cpbcon_(char *uplo, integer *n, integer *kd, complex *ab,+	 integer *ldab, real *anorm, real *rcond, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int cpbequ_(char *uplo, integer *n, integer *kd, complex *ab,+	 integer *ldab, real *s, real *scond, real *amax, integer *info);+ +/* Subroutine */ int cpbrfs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, complex *ab, integer *ldab, complex *afb, integer *ldafb, +	complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *+	berr, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cpbstf_(char *uplo, integer *n, integer *kd, complex *ab,+	 integer *ldab, integer *info);+ +/* Subroutine */ int cpbsv_(char *uplo, integer *n, integer *kd, integer *+	nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int cpbsvx_(char *fact, char *uplo, integer *n, integer *kd, +	integer *nrhs, complex *ab, integer *ldab, complex *afb, integer *+	ldafb, char *equed, real *s, complex *b, integer *ldb, complex *x, +	integer *ldx, real *rcond, real *ferr, real *berr, complex *work, +	real *rwork, integer *info);+ +/* Subroutine */ int cpbtf2_(char *uplo, integer *n, integer *kd, complex *ab,+	 integer *ldab, integer *info);+ +/* Subroutine */ int cpbtrf_(char *uplo, integer *n, integer *kd, complex *ab,+	 integer *ldab, integer *info);+ +/* Subroutine */ int cpbtrs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int cpocon_(char *uplo, integer *n, complex *a, integer *lda,+	 real *anorm, real *rcond, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cpoequ_(integer *n, complex *a, integer *lda, real *s, +	real *scond, real *amax, integer *info);+ +/* Subroutine */ int cporfs_(char *uplo, integer *n, integer *nrhs, complex *+	a, integer *lda, complex *af, integer *ldaf, complex *b, integer *ldb,+	 complex *x, integer *ldx, real *ferr, real *berr, complex *work, +	real *rwork, integer *info);+ +/* Subroutine */ int cposv_(char *uplo, integer *n, integer *nrhs, complex *a,+	 integer *lda, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cposvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, char *+	equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, +	real *rcond, real *ferr, real *berr, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int cpotf2_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *info);+ +/* Subroutine */ int cpotrf_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *info);+ +/* Subroutine */ int cpotri_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *info);+ +/* Subroutine */ int cpotrs_(char *uplo, integer *n, integer *nrhs, complex *+	a, integer *lda, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cppcon_(char *uplo, integer *n, complex *ap, real *anorm,+	 real *rcond, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cppequ_(char *uplo, integer *n, complex *ap, real *s, +	real *scond, real *amax, integer *info);+ +/* Subroutine */ int cpprfs_(char *uplo, integer *n, integer *nrhs, complex *+	ap, complex *afp, complex *b, integer *ldb, complex *x, integer *ldx, +	real *ferr, real *berr, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cppsv_(char *uplo, integer *n, integer *nrhs, complex *+	ap, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cppsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, complex *ap, complex *afp, char *equed, real *s, complex *b, +	integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real +	*berr, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int cpptrf_(char *uplo, integer *n, complex *ap, integer *+	info);+ +/* Subroutine */ int cpptri_(char *uplo, integer *n, complex *ap, integer *+	info);+ +/* Subroutine */ int cpptrs_(char *uplo, integer *n, integer *nrhs, complex *+	ap, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cptcon_(integer *n, real *d__, complex *e, real *anorm, +	real *rcond, real *rwork, integer *info);+ +/* Subroutine */ int cptrfs_(char *uplo, integer *n, integer *nrhs, real *d__,+	 complex *e, real *df, complex *ef, complex *b, integer *ldb, complex +	*x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int cptsv_(integer *n, integer *nrhs, real *d__, complex *e, +	complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cptsvx_(char *fact, integer *n, integer *nrhs, real *d__,+	 complex *e, real *df, complex *ef, complex *b, integer *ldb, complex +	*x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, +	real *rwork, integer *info);+ +/* Subroutine */ int cpttrf_(integer *n, real *d__, complex *e, integer *info);+ +/* Subroutine */ int cpttrs_(char *uplo, integer *n, integer *nrhs, real *d__,+	 complex *e, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cptts2_(integer *iuplo, integer *n, integer *nrhs, real *+	d__, complex *e, complex *b, integer *ldb);+ +/* Subroutine */ int crot_(integer *n, complex *cx, integer *incx, complex *+	cy, integer *incy, real *c__, complex *s);+ +/* Subroutine */ int cspcon_(char *uplo, integer *n, complex *ap, integer *+	ipiv, real *anorm, real *rcond, complex *work, integer *info);+ +/* Subroutine */ int cspmv_(char *uplo, integer *n, complex *alpha, complex *+	ap, complex *x, integer *incx, complex *beta, complex *y, integer *+	incy);+ +/* Subroutine */ int cspr_(char *uplo, integer *n, complex *alpha, complex *x,+	 integer *incx, complex *ap);+ +/* Subroutine */ int csprfs_(char *uplo, integer *n, integer *nrhs, complex *+	ap, complex *afp, integer *ipiv, complex *b, integer *ldb, complex *x,+	 integer *ldx, real *ferr, real *berr, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int cspsv_(char *uplo, integer *n, integer *nrhs, complex *+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int cspsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, complex *ap, complex *afp, integer *ipiv, complex *b, integer *+	ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int csptrf_(char *uplo, integer *n, complex *ap, integer *+	ipiv, integer *info);+ +/* Subroutine */ int csptri_(char *uplo, integer *n, complex *ap, integer *+	ipiv, complex *work, integer *info);+ +/* Subroutine */ int csptrs_(char *uplo, integer *n, integer *nrhs, complex *+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int csrot_(integer *n, complex *cx, integer *incx, complex *+	cy, integer *incy, real *c__, real *s);+ +/* Subroutine */ int csrscl_(integer *n, real *sa, complex *sx, integer *incx);+ +/* Subroutine */ int cstedc_(char *compz, integer *n, real *d__, real *e, +	complex *z__, integer *ldz, complex *work, integer *lwork, real *+	rwork, integer *lrwork, integer *iwork, integer *liwork, integer *+	info);+ +/* Subroutine */ int cstein_(integer *n, real *d__, real *e, integer *m, real +	*w, integer *iblock, integer *isplit, complex *z__, integer *ldz, +	real *work, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int csteqr_(char *compz, integer *n, real *d__, real *e, +	complex *z__, integer *ldz, real *work, integer *info);+ +/* Subroutine */ int csycon_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, real *anorm, real *rcond, complex *work, integer *+	info);+ +/* Subroutine */ int csymv_(char *uplo, integer *n, complex *alpha, complex *+	a, integer *lda, complex *x, integer *incx, complex *beta, complex *y,+	 integer *incy);+ +/* Subroutine */ int csyr_(char *uplo, integer *n, complex *alpha, complex *x,+	 integer *incx, complex *a, integer *lda);+ +/* Subroutine */ int csyrfs_(char *uplo, integer *n, integer *nrhs, complex *+	a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *+	b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int csysv_(char *uplo, integer *n, integer *nrhs, complex *a,+	 integer *lda, integer *ipiv, complex *b, integer *ldb, complex *work,+	 integer *lwork, integer *info);+ +/* Subroutine */ int csysvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *+	ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond,+	 real *ferr, real *berr, complex *work, integer *lwork, real *rwork, +	integer *info);+ +/* Subroutine */ int csytf2_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, integer *info);+ +/* Subroutine */ int csytrf_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int csytri_(char *uplo, integer *n, complex *a, integer *lda,+	 integer *ipiv, complex *work, integer *info);+ +/* Subroutine */ int csytrs_(char *uplo, integer *n, integer *nrhs, complex *+	a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int ctbcon_(char *norm, char *uplo, char *diag, integer *n, +	integer *kd, complex *ab, integer *ldab, real *rcond, complex *work, +	real *rwork, integer *info);+ +/* Subroutine */ int ctbrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, complex *ab, integer *ldab, complex *b, +	integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, +	complex *work, real *rwork, integer *info);+ +/* Subroutine */ int ctbtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, complex *ab, integer *ldab, complex *b, +	integer *ldb, integer *info);+ +/* Subroutine */ int ctgevc_(char *side, char *howmny, logical *select, +	integer *n, complex *a, integer *lda, complex *b, integer *ldb, +	complex *vl, integer *ldvl, complex *vr, integer *ldvr, integer *mm, +	integer *m, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int ctgex2_(logical *wantq, logical *wantz, integer *n, +	complex *a, integer *lda, complex *b, integer *ldb, complex *q, +	integer *ldq, complex *z__, integer *ldz, integer *j1, integer *info);+ +/* Subroutine */ int ctgexc_(logical *wantq, logical *wantz, integer *n, +	complex *a, integer *lda, complex *b, integer *ldb, complex *q, +	integer *ldq, complex *z__, integer *ldz, integer *ifst, integer *+	ilst, integer *info);+ +/* Subroutine */ int ctgsen_(integer *ijob, logical *wantq, logical *wantz, +	logical *select, integer *n, complex *a, integer *lda, complex *b, +	integer *ldb, complex *alpha, complex *beta, complex *q, integer *ldq,+	 complex *z__, integer *ldz, integer *m, real *pl, real *pr, real *+	dif, complex *work, integer *lwork, integer *iwork, integer *liwork, +	integer *info);+ +/* Subroutine */ int ctgsja_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, integer *k, integer *l, complex *a, integer *+	lda, complex *b, integer *ldb, real *tola, real *tolb, real *alpha, +	real *beta, complex *u, integer *ldu, complex *v, integer *ldv, +	complex *q, integer *ldq, complex *work, integer *ncycle, integer *+	info);+ +/* Subroutine */ int ctgsna_(char *job, char *howmny, logical *select, +	integer *n, complex *a, integer *lda, complex *b, integer *ldb, +	complex *vl, integer *ldvl, complex *vr, integer *ldvr, real *s, real +	*dif, integer *mm, integer *m, complex *work, integer *lwork, integer +	*iwork, integer *info);+ +/* Subroutine */ int ctgsy2_(char *trans, integer *ijob, integer *m, integer *+	n, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, +	integer *ldc, complex *d__, integer *ldd, complex *e, integer *lde, +	complex *f, integer *ldf, real *scale, real *rdsum, real *rdscal, +	integer *info);+ +/* Subroutine */ int ctgsyl_(char *trans, integer *ijob, integer *m, integer *+	n, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, +	integer *ldc, complex *d__, integer *ldd, complex *e, integer *lde, +	complex *f, integer *ldf, real *scale, real *dif, complex *work, +	integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int ctpcon_(char *norm, char *uplo, char *diag, integer *n, +	complex *ap, real *rcond, complex *work, real *rwork, integer *info);+ +/* Subroutine */ int ctprfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, complex *ap, complex *b, integer *ldb, complex *x, +	integer *ldx, real *ferr, real *berr, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int ctptri_(char *uplo, char *diag, integer *n, complex *ap, +	integer *info);+ +/* Subroutine */ int ctptrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, complex *ap, complex *b, integer *ldb, integer *info);+ +/* Subroutine */ int ctrcon_(char *norm, char *uplo, char *diag, integer *n, +	complex *a, integer *lda, real *rcond, complex *work, real *rwork, +	integer *info);+ +/* Subroutine */ int ctrevc_(char *side, char *howmny, logical *select, +	integer *n, complex *t, integer *ldt, complex *vl, integer *ldvl, +	complex *vr, integer *ldvr, integer *mm, integer *m, complex *work, +	real *rwork, integer *info);+ +/* Subroutine */ int ctrexc_(char *compq, integer *n, complex *t, integer *+	ldt, complex *q, integer *ldq, integer *ifst, integer *ilst, integer *+	info);+ +/* Subroutine */ int ctrrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, complex *a, integer *lda, complex *b, integer *ldb, +	complex *x, integer *ldx, real *ferr, real *berr, complex *work, real +	*rwork, integer *info);+ +/* Subroutine */ int ctrsen_(char *job, char *compq, logical *select, integer +	*n, complex *t, integer *ldt, complex *q, integer *ldq, complex *w, +	integer *m, real *s, real *sep, complex *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int ctrsna_(char *job, char *howmny, logical *select, +	integer *n, complex *t, integer *ldt, complex *vl, integer *ldvl, +	complex *vr, integer *ldvr, real *s, real *sep, integer *mm, integer *+	m, complex *work, integer *ldwork, real *rwork, integer *info);+ +/* Subroutine */ int ctrsyl_(char *trana, char *tranb, integer *isgn, integer +	*m, integer *n, complex *a, integer *lda, complex *b, integer *ldb, +	complex *c__, integer *ldc, real *scale, integer *info);+ +/* Subroutine */ int ctrti2_(char *uplo, char *diag, integer *n, complex *a, +	integer *lda, integer *info);+ +/* Subroutine */ int ctrtri_(char *uplo, char *diag, integer *n, complex *a, +	integer *lda, integer *info);+ +/* Subroutine */ int ctrtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, complex *a, integer *lda, complex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int ctzrqf_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, integer *info);+ +/* Subroutine */ int ctzrzf_(integer *m, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cung2l_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cung2r_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cungbr_(char *vect, integer *m, integer *n, integer *k, +	complex *a, integer *lda, complex *tau, complex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int cunghr_(integer *n, integer *ilo, integer *ihi, complex *+	a, integer *lda, complex *tau, complex *work, integer *lwork, integer +	*info);+ +/* Subroutine */ int cungl2_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cunglq_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int cungql_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int cungqr_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int cungr2_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *info);+ +/* Subroutine */ int cungrq_(integer *m, integer *n, integer *k, complex *a, +	integer *lda, complex *tau, complex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int cungtr_(char *uplo, integer *n, complex *a, integer *lda,+	 complex *tau, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cunm2l_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *info);+ +/* Subroutine */ int cunm2r_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *info);+ +/* Subroutine */ int cunmbr_(char *vect, char *side, char *trans, integer *m, +	integer *n, integer *k, complex *a, integer *lda, complex *tau, +	complex *c__, integer *ldc, complex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int cunmhr_(char *side, char *trans, integer *m, integer *n, +	integer *ilo, integer *ihi, complex *a, integer *lda, complex *tau, +	complex *c__, integer *ldc, complex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int cunml2_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *info);+ +/* Subroutine */ int cunmlq_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cunmql_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cunmqr_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cunmr2_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *info);+ +/* Subroutine */ int cunmr3_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, complex *a, integer *lda, complex *tau, +	complex *c__, integer *ldc, complex *work, integer *info);+ +/* Subroutine */ int cunmrq_(char *side, char *trans, integer *m, integer *n, +	integer *k, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cunmrz_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, complex *a, integer *lda, complex *tau, +	complex *c__, integer *ldc, complex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int cunmtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, complex *a, integer *lda, complex *tau, complex *c__, +	integer *ldc, complex *work, integer *lwork, integer *info);+ +/* Subroutine */ int cupgtr_(char *uplo, integer *n, complex *ap, complex *+	tau, complex *q, integer *ldq, complex *work, integer *info);+ +/* Subroutine */ int cupmtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, complex *ap, complex *tau, complex *c__, integer *ldc, +	complex *work, integer *info);+ +/* Subroutine */ int dbdsdc_(char *uplo, char *compq, integer *n, doublereal *+	d__, doublereal *e, doublereal *u, integer *ldu, doublereal *vt, +	integer *ldvt, doublereal *q, integer *iq, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dbdsqr_(char *uplo, integer *n, integer *ncvt, integer *+	nru, integer *ncc, doublereal *d__, doublereal *e, doublereal *vt, +	integer *ldvt, doublereal *u, integer *ldu, doublereal *c__, integer *+	ldc, doublereal *work, integer *info);+ +/* Subroutine */ int ddisna_(char *job, integer *m, integer *n, doublereal *+	d__, doublereal *sep, integer *info);+ +/* Subroutine */ int dgbbrd_(char *vect, integer *m, integer *n, integer *ncc,+	 integer *kl, integer *ku, doublereal *ab, integer *ldab, doublereal *+	d__, doublereal *e, doublereal *q, integer *ldq, doublereal *pt, +	integer *ldpt, doublereal *c__, integer *ldc, doublereal *work, +	integer *info);+ +/* Subroutine */ int dgbcon_(char *norm, integer *n, integer *kl, integer *ku,+	 doublereal *ab, integer *ldab, integer *ipiv, doublereal *anorm, +	doublereal *rcond, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dgbequ_(integer *m, integer *n, integer *kl, integer *ku,+	 doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, +	doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *+	info);+ +/* Subroutine */ int dgbrfs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, +	integer *ldafb, integer *ipiv, doublereal *b, integer *ldb, +	doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dgbsv_(integer *n, integer *kl, integer *ku, integer *+	nrhs, doublereal *ab, integer *ldab, integer *ipiv, doublereal *b, +	integer *ldb, integer *info);+ +/* Subroutine */ int dgbsvx_(char *fact, char *trans, integer *n, integer *kl,+	 integer *ku, integer *nrhs, doublereal *ab, integer *ldab, +	doublereal *afb, integer *ldafb, integer *ipiv, char *equed, +	doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, +	doublereal *x, integer *ldx, doublereal *rcond, doublereal *ferr, +	doublereal *berr, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dgbtf2_(integer *m, integer *n, integer *kl, integer *ku,+	 doublereal *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int dgbtrf_(integer *m, integer *n, integer *kl, integer *ku,+	 doublereal *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int dgbtrs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, doublereal *ab, integer *ldab, integer *ipiv, +	doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dgebak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, doublereal *scale, integer *m, doublereal *v, integer *+	ldv, integer *info);+ +/* Subroutine */ int dgebal_(char *job, integer *n, doublereal *a, integer *+	lda, integer *ilo, integer *ihi, doublereal *scale, integer *info);+ +/* Subroutine */ int dgebd2_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *d__, doublereal *e, doublereal *tauq, doublereal *+	taup, doublereal *work, integer *info);+ +/* Subroutine */ int dgebrd_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *d__, doublereal *e, doublereal *tauq, doublereal *+	taup, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dgecon_(char *norm, integer *n, doublereal *a, integer *+	lda, doublereal *anorm, doublereal *rcond, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dgeequ_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal +	*colcnd, doublereal *amax, integer *info);+ +/* Subroutine */ int dgees_(char *jobvs, char *sort, L_fp select, integer *n, +	doublereal *a, integer *lda, integer *sdim, doublereal *wr, +	doublereal *wi, doublereal *vs, integer *ldvs, doublereal *work, +	integer *lwork, logical *bwork, integer *info);+ +/* Subroutine */ int dgeesx_(char *jobvs, char *sort, L_fp select, char *+	sense, integer *n, doublereal *a, integer *lda, integer *sdim, +	doublereal *wr, doublereal *wi, doublereal *vs, integer *ldvs, +	doublereal *rconde, doublereal *rcondv, doublereal *work, integer *+	lwork, integer *iwork, integer *liwork, logical *bwork, integer *info);+ +/* Subroutine */ int dgeev_(char *jobvl, char *jobvr, integer *n, doublereal *+	a, integer *lda, doublereal *wr, doublereal *wi, doublereal *vl, +	integer *ldvl, doublereal *vr, integer *ldvr, doublereal *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int dgeevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, doublereal *a, integer *lda, doublereal *wr, +	doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, +	integer *ldvr, integer *ilo, integer *ihi, doublereal *scale, +	doublereal *abnrm, doublereal *rconde, doublereal *rcondv, doublereal +	*work, integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int dgegs_(char *jobvsl, char *jobvsr, integer *n, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *+	alphar, doublereal *alphai, doublereal *beta, doublereal *vsl, +	integer *ldvsl, doublereal *vsr, integer *ldvsr, doublereal *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int dgegv_(char *jobvl, char *jobvr, integer *n, doublereal *+	a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, +	doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl, +	doublereal *vr, integer *ldvr, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dgehd2_(integer *n, integer *ilo, integer *ihi, +	doublereal *a, integer *lda, doublereal *tau, doublereal *work, +	integer *info);+ +/* Subroutine */ int dgehrd_(integer *n, integer *ilo, integer *ihi, +	doublereal *a, integer *lda, doublereal *tau, doublereal *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int dgelq2_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dgelqf_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dgels_(char *trans, integer *m, integer *n, integer *+	nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, +	doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dgelsd_(integer *m, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *+	s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork,+	 integer *iwork, integer *info);+ +/* Subroutine */ int dgelss_(integer *m, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *+	s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int dgelsx_(integer *m, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *+	jpvt, doublereal *rcond, integer *rank, doublereal *work, integer *+	info);+ +/* Subroutine */ int dgelsy_(integer *m, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *+	jpvt, doublereal *rcond, integer *rank, doublereal *work, integer *+	lwork, integer *info);+ +/* Subroutine */ int dgeql2_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dgeqlf_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dgeqp3_(integer *m, integer *n, doublereal *a, integer *+	lda, integer *jpvt, doublereal *tau, doublereal *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int dgeqpf_(integer *m, integer *n, doublereal *a, integer *+	lda, integer *jpvt, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dgeqr2_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dgeqrf_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dgerfs_(char *trans, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *+	ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, +	doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dgerq2_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dgerqf_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dgesc2_(integer *n, doublereal *a, integer *lda, +	doublereal *rhs, integer *ipiv, integer *jpiv, doublereal *scale);+ +/* Subroutine */ int dgesdd_(char *jobz, integer *m, integer *n, doublereal *+	a, integer *lda, doublereal *s, doublereal *u, integer *ldu, +	doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, +	integer *iwork, integer *info);+ +/* Subroutine */ int dgesv_(integer *n, integer *nrhs, doublereal *a, integer +	*lda, integer *ipiv, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dgesvd_(char *jobu, char *jobvt, integer *m, integer *n, +	doublereal *a, integer *lda, doublereal *s, doublereal *u, integer *+	ldu, doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dgesvx_(char *fact, char *trans, integer *n, integer *+	nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, +	integer *ipiv, char *equed, doublereal *r__, doublereal *c__, +	doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *+	rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dgetc2_(integer *n, doublereal *a, integer *lda, integer +	*ipiv, integer *jpiv, integer *info);+ +/* Subroutine */ int dgetf2_(integer *m, integer *n, doublereal *a, integer *+	lda, integer *ipiv, integer *info);+ +/* Subroutine */ int dgetrf_(integer *m, integer *n, doublereal *a, integer *+	lda, integer *ipiv, integer *info);+ +/* Subroutine */ int dgetri_(integer *n, doublereal *a, integer *lda, integer +	*ipiv, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dgetrs_(char *trans, integer *n, integer *nrhs, +	doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *+	ldb, integer *info);+ +/* Subroutine */ int dggbak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, doublereal *lscale, doublereal *rscale, integer *m, +	doublereal *v, integer *ldv, integer *info);+ +/* Subroutine */ int dggbal_(char *job, integer *n, doublereal *a, integer *+	lda, doublereal *b, integer *ldb, integer *ilo, integer *ihi, +	doublereal *lscale, doublereal *rscale, doublereal *work, integer *+	info);+ +/* Subroutine */ int dgges_(char *jobvsl, char *jobvsr, char *sort, L_fp +	delctg, integer *n, doublereal *a, integer *lda, doublereal *b, +	integer *ldb, integer *sdim, doublereal *alphar, doublereal *alphai, +	doublereal *beta, doublereal *vsl, integer *ldvsl, doublereal *vsr, +	integer *ldvsr, doublereal *work, integer *lwork, logical *bwork, +	integer *info);+ +/* Subroutine */ int dggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp +	delctg, char *sense, integer *n, doublereal *a, integer *lda, +	doublereal *b, integer *ldb, integer *sdim, doublereal *alphar, +	doublereal *alphai, doublereal *beta, doublereal *vsl, integer *ldvsl,+	 doublereal *vsr, integer *ldvsr, doublereal *rconde, doublereal *+	rcondv, doublereal *work, integer *lwork, integer *iwork, integer *+	liwork, logical *bwork, integer *info);+ +/* Subroutine */ int dggev_(char *jobvl, char *jobvr, integer *n, doublereal *+	a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, +	doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl, +	doublereal *vr, integer *ldvr, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, doublereal *a, integer *lda, doublereal *b, +	integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *+	beta, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, +	integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, +	doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal *+	rcondv, doublereal *work, integer *lwork, integer *iwork, logical *+	bwork, integer *info);+ +/* Subroutine */ int dggglm_(integer *n, integer *m, integer *p, doublereal *+	a, integer *lda, doublereal *b, integer *ldb, doublereal *d__, +	doublereal *x, doublereal *y, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dgghrd_(char *compq, char *compz, integer *n, integer *+	ilo, integer *ihi, doublereal *a, integer *lda, doublereal *b, +	integer *ldb, doublereal *q, integer *ldq, doublereal *z__, integer *+	ldz, integer *info);+ +/* Subroutine */ int dgglse_(integer *m, integer *n, integer *p, doublereal *+	a, integer *lda, doublereal *b, integer *ldb, doublereal *c__, +	doublereal *d__, doublereal *x, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dggqrf_(integer *n, integer *m, integer *p, doublereal *+	a, integer *lda, doublereal *taua, doublereal *b, integer *ldb, +	doublereal *taub, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dggrqf_(integer *m, integer *p, integer *n, doublereal *+	a, integer *lda, doublereal *taua, doublereal *b, integer *ldb, +	doublereal *taub, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dggsvd_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *n, integer *p, integer *k, integer *l, doublereal *a, +	integer *lda, doublereal *b, integer *ldb, doublereal *alpha, +	doublereal *beta, doublereal *u, integer *ldu, doublereal *v, integer +	*ldv, doublereal *q, integer *ldq, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dggsvp_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, doublereal *a, integer *lda, doublereal *b, +	integer *ldb, doublereal *tola, doublereal *tolb, integer *k, integer +	*l, doublereal *u, integer *ldu, doublereal *v, integer *ldv, +	doublereal *q, integer *ldq, integer *iwork, doublereal *tau, +	doublereal *work, integer *info);+ +/* Subroutine */ int dgtcon_(char *norm, integer *n, doublereal *dl, +	doublereal *d__, doublereal *du, doublereal *du2, integer *ipiv, +	doublereal *anorm, doublereal *rcond, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dgtrfs_(char *trans, integer *n, integer *nrhs, +	doublereal *dl, doublereal *d__, doublereal *du, doublereal *dlf, +	doublereal *df, doublereal *duf, doublereal *du2, integer *ipiv, +	doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *+	ferr, doublereal *berr, doublereal *work, integer *iwork, integer *+	info);+ +/* Subroutine */ int dgtsv_(integer *n, integer *nrhs, doublereal *dl, +	doublereal *d__, doublereal *du, doublereal *b, integer *ldb, integer +	*info);+ +/* Subroutine */ int dgtsvx_(char *fact, char *trans, integer *n, integer *+	nrhs, doublereal *dl, doublereal *d__, doublereal *du, doublereal *+	dlf, doublereal *df, doublereal *duf, doublereal *du2, integer *ipiv, +	doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *+	rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dgttrf_(integer *n, doublereal *dl, doublereal *d__, +	doublereal *du, doublereal *du2, integer *ipiv, integer *info);+ +/* Subroutine */ int dgttrs_(char *trans, integer *n, integer *nrhs, +	doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, +	integer *ipiv, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dgtts2_(integer *itrans, integer *n, integer *nrhs, +	doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, +	integer *ipiv, doublereal *b, integer *ldb);+ +/* Subroutine */ int dhgeqz_(char *job, char *compq, char *compz, integer *n, +	integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal *+	b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *+	beta, doublereal *q, integer *ldq, doublereal *z__, integer *ldz, +	doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dhsein_(char *side, char *eigsrc, char *initv, logical *+	select, integer *n, doublereal *h__, integer *ldh, doublereal *wr, +	doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, +	integer *ldvr, integer *mm, integer *m, doublereal *work, integer *+	ifaill, integer *ifailr, integer *info);+ +/* Subroutine */ int dhseqr_(char *job, char *compz, integer *n, integer *ilo,+	 integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, +	doublereal *wi, doublereal *z__, integer *ldz, doublereal *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int dlabad_(doublereal *small, doublereal *large);+ +/* Subroutine */ int dlabrd_(integer *m, integer *n, integer *nb, doublereal *+	a, integer *lda, doublereal *d__, doublereal *e, doublereal *tauq, +	doublereal *taup, doublereal *x, integer *ldx, doublereal *y, integer +	*ldy);+ +/* Subroutine */ int dlacon_(integer *n, doublereal *v, doublereal *x, +	integer *isgn, doublereal *est, integer *kase);+ +/* Subroutine */ int dlacpy_(char *uplo, integer *m, integer *n, doublereal *+	a, integer *lda, doublereal *b, integer *ldb);+ +/* Subroutine */ int dladiv_(doublereal *a, doublereal *b, doublereal *c__, +	doublereal *d__, doublereal *p, doublereal *q);+ +/* Subroutine */ int dlae2_(doublereal *a, doublereal *b, doublereal *c__, +	doublereal *rt1, doublereal *rt2);+ +/* Subroutine */ int dlaebz_(integer *ijob, integer *nitmax, integer *n, +	integer *mmax, integer *minp, integer *nbmin, doublereal *abstol, +	doublereal *reltol, doublereal *pivmin, doublereal *d__, doublereal *+	e, doublereal *e2, integer *nval, doublereal *ab, doublereal *c__, +	integer *mout, integer *nab, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dlaed0_(integer *icompq, integer *qsiz, integer *n, +	doublereal *d__, doublereal *e, doublereal *q, integer *ldq, +	doublereal *qstore, integer *ldqs, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dlaed1_(integer *n, doublereal *d__, doublereal *q, +	integer *ldq, integer *indxq, doublereal *rho, integer *cutpnt, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dlaed2_(integer *k, integer *n, integer *n1, doublereal *+	d__, doublereal *q, integer *ldq, integer *indxq, doublereal *rho, +	doublereal *z__, doublereal *dlamda, doublereal *w, doublereal *q2, +	integer *indx, integer *indxc, integer *indxp, integer *coltyp, +	integer *info);+ +/* Subroutine */ int dlaed3_(integer *k, integer *n, integer *n1, doublereal *+	d__, doublereal *q, integer *ldq, doublereal *rho, doublereal *dlamda,+	 doublereal *q2, integer *indx, integer *ctot, doublereal *w, +	doublereal *s, integer *info);+ +/* Subroutine */ int dlaed4_(integer *n, integer *i__, doublereal *d__, +	doublereal *z__, doublereal *delta, doublereal *rho, doublereal *dlam,+	 integer *info);+ +/* Subroutine */ int dlaed5_(integer *i__, doublereal *d__, doublereal *z__, +	doublereal *delta, doublereal *rho, doublereal *dlam);+ +/* Subroutine */ int dlaed6_(integer *kniter, logical *orgati, doublereal *+	rho, doublereal *d__, doublereal *z__, doublereal *finit, doublereal *+	tau, integer *info);+ +/* Subroutine */ int dlaed7_(integer *icompq, integer *n, integer *qsiz, +	integer *tlvls, integer *curlvl, integer *curpbm, doublereal *d__, +	doublereal *q, integer *ldq, integer *indxq, doublereal *rho, integer +	*cutpnt, doublereal *qstore, integer *qptr, integer *prmptr, integer *+	perm, integer *givptr, integer *givcol, doublereal *givnum, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dlaed8_(integer *icompq, integer *k, integer *n, integer +	*qsiz, doublereal *d__, doublereal *q, integer *ldq, integer *indxq, +	doublereal *rho, integer *cutpnt, doublereal *z__, doublereal *dlamda,+	 doublereal *q2, integer *ldq2, doublereal *w, integer *perm, integer +	*givptr, integer *givcol, doublereal *givnum, integer *indxp, integer +	*indx, integer *info);+ +/* Subroutine */ int dlaed9_(integer *k, integer *kstart, integer *kstop, +	integer *n, doublereal *d__, doublereal *q, integer *ldq, doublereal *+	rho, doublereal *dlamda, doublereal *w, doublereal *s, integer *lds, +	integer *info);+ +/* Subroutine */ int dlaeda_(integer *n, integer *tlvls, integer *curlvl, +	integer *curpbm, integer *prmptr, integer *perm, integer *givptr, +	integer *givcol, doublereal *givnum, doublereal *q, integer *qptr, +	doublereal *z__, doublereal *ztemp, integer *info);+ +/* Subroutine */ int dlaein_(logical *rightv, logical *noinit, integer *n, +	doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, +	doublereal *vr, doublereal *vi, doublereal *b, integer *ldb, +	doublereal *work, doublereal *eps3, doublereal *smlnum, doublereal *+	bignum, integer *info);+ +/* Subroutine */ int dlaev2_(doublereal *a, doublereal *b, doublereal *c__, +	doublereal *rt1, doublereal *rt2, doublereal *cs1, doublereal *sn1);+ +/* Subroutine */ int dlaexc_(logical *wantq, integer *n, doublereal *t, +	integer *ldt, doublereal *q, integer *ldq, integer *j1, integer *n1, +	integer *n2, doublereal *work, integer *info);+ +/* Subroutine */ int dlag2_(doublereal *a, integer *lda, doublereal *b, +	integer *ldb, doublereal *safmin, doublereal *scale1, doublereal *+	scale2, doublereal *wr1, doublereal *wr2, doublereal *wi);+ +/* Subroutine */ int dlags2_(logical *upper, doublereal *a1, doublereal *a2, +	doublereal *a3, doublereal *b1, doublereal *b2, doublereal *b3, +	doublereal *csu, doublereal *snu, doublereal *csv, doublereal *snv, +	doublereal *csq, doublereal *snq);+ +/* Subroutine */ int dlagtf_(integer *n, doublereal *a, doublereal *lambda, +	doublereal *b, doublereal *c__, doublereal *tol, doublereal *d__, +	integer *in, integer *info);+ +/* Subroutine */ int dlagtm_(char *trans, integer *n, integer *nrhs, +	doublereal *alpha, doublereal *dl, doublereal *d__, doublereal *du, +	doublereal *x, integer *ldx, doublereal *beta, doublereal *b, integer +	*ldb);+ +/* Subroutine */ int dlagts_(integer *job, integer *n, doublereal *a, +	doublereal *b, doublereal *c__, doublereal *d__, integer *in, +	doublereal *y, doublereal *tol, integer *info);+ +/* Subroutine */ int dlagv2_(doublereal *a, integer *lda, doublereal *b, +	integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *+	beta, doublereal *csl, doublereal *snl, doublereal *csr, doublereal *+	snr);+ +/* Subroutine */ int dlahqr_(logical *wantt, logical *wantz, integer *n, +	integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal +	*wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, +	integer *ldz, integer *info);+ +/* Subroutine */ int dlahrd_(integer *n, integer *k, integer *nb, doublereal *+	a, integer *lda, doublereal *tau, doublereal *t, integer *ldt, +	doublereal *y, integer *ldy);+ +/* Subroutine */ int dlaic1_(integer *job, integer *j, doublereal *x, +	doublereal *sest, doublereal *w, doublereal *gamma, doublereal *+	sestpr, doublereal *s, doublereal *c__);+ +/* Subroutine */ int dlaln2_(logical *ltrans, integer *na, integer *nw, +	doublereal *smin, doublereal *ca, doublereal *a, integer *lda, +	doublereal *d1, doublereal *d2, doublereal *b, integer *ldb, +	doublereal *wr, doublereal *wi, doublereal *x, integer *ldx, +	doublereal *scale, doublereal *xnorm, integer *info);+ +/* Subroutine */ int dlals0_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, integer *nrhs, doublereal *b, integer *ldb, doublereal +	*bx, integer *ldbx, integer *perm, integer *givptr, integer *givcol, +	integer *ldgcol, doublereal *givnum, integer *ldgnum, doublereal *+	poles, doublereal *difl, doublereal *difr, doublereal *z__, integer *+	k, doublereal *c__, doublereal *s, doublereal *work, integer *info);+ +/* Subroutine */ int dlalsa_(integer *icompq, integer *smlsiz, integer *n, +	integer *nrhs, doublereal *b, integer *ldb, doublereal *bx, integer *+	ldbx, doublereal *u, integer *ldu, doublereal *vt, integer *k, +	doublereal *difl, doublereal *difr, doublereal *z__, doublereal *+	poles, integer *givptr, integer *givcol, integer *ldgcol, integer *+	perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int dlalsd_(char *uplo, integer *smlsiz, integer *n, integer +	*nrhs, doublereal *d__, doublereal *e, doublereal *b, integer *ldb, +	doublereal *rcond, integer *rank, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dlamc1_(integer *beta, integer *t, logical *rnd, logical +	*ieee1);+ +/* Subroutine */ int dlamc2_(integer *beta, integer *t, logical *rnd, +	doublereal *eps, integer *emin, doublereal *rmin, integer *emax, +	doublereal *rmax);+ +/* Subroutine */ int dlamc4_(integer *emin, doublereal *start, integer *base);+ +/* Subroutine */ int dlamc5_(integer *beta, integer *p, integer *emin, +	logical *ieee, integer *emax, doublereal *rmax);+ +/* Subroutine */ int dlamrg_(integer *n1, integer *n2, doublereal *a, integer +	*dtrd1, integer *dtrd2, integer *index);+ +/* Subroutine */ int dlanv2_(doublereal *a, doublereal *b, doublereal *c__, +	doublereal *d__, doublereal *rt1r, doublereal *rt1i, doublereal *rt2r,+	 doublereal *rt2i, doublereal *cs, doublereal *sn);+ +/* Subroutine */ int dlapll_(integer *n, doublereal *x, integer *incx, +	doublereal *y, integer *incy, doublereal *ssmin);+ +/* Subroutine */ int dlapmt_(logical *forwrd, integer *m, integer *n, +	doublereal *x, integer *ldx, integer *k);+ +/* Subroutine */ int dlaqgb_(integer *m, integer *n, integer *kl, integer *ku,+	 doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, +	doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed);+ +/* Subroutine */ int dlaqge_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal +	*colcnd, doublereal *amax, char *equed);+ +/* Subroutine */ int dlaqp2_(integer *m, integer *n, integer *offset, +	doublereal *a, integer *lda, integer *jpvt, doublereal *tau, +	doublereal *vn1, doublereal *vn2, doublereal *work);+ +/* Subroutine */ int dlaqps_(integer *m, integer *n, integer *offset, integer +	*nb, integer *kb, doublereal *a, integer *lda, integer *jpvt, +	doublereal *tau, doublereal *vn1, doublereal *vn2, doublereal *auxv, +	doublereal *f, integer *ldf);+ +/* Subroutine */ int dlaqsb_(char *uplo, integer *n, integer *kd, doublereal *+	ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax,+	 char *equed);+ +/* Subroutine */ int dlaqsp_(char *uplo, integer *n, doublereal *ap, +	doublereal *s, doublereal *scond, doublereal *amax, char *equed);+ +/* Subroutine */ int dlaqsy_(char *uplo, integer *n, doublereal *a, integer *+	lda, doublereal *s, doublereal *scond, doublereal *amax, char *equed);+ +/* Subroutine */ int dlaqtr_(logical *ltran, logical *lreal, integer *n, +	doublereal *t, integer *ldt, doublereal *b, doublereal *w, doublereal +	*scale, doublereal *x, doublereal *work, integer *info);+ +/* Subroutine */ int dlar1v_(integer *n, integer *b1, integer *bn, doublereal +	*sigma, doublereal *d__, doublereal *l, doublereal *ld, doublereal *+	lld, doublereal *gersch, doublereal *z__, doublereal *ztz, doublereal +	*mingma, integer *r__, integer *isuppz, doublereal *work);+ +/* Subroutine */ int dlar2v_(integer *n, doublereal *x, doublereal *y, +	doublereal *z__, integer *incx, doublereal *c__, doublereal *s, +	integer *incc);+ +/* Subroutine */ int dlarf_(char *side, integer *m, integer *n, doublereal *v,+	 integer *incv, doublereal *tau, doublereal *c__, integer *ldc, +	doublereal *work);+ +/* Subroutine */ int dlarfb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, doublereal *v, integer *+	ldv, doublereal *t, integer *ldt, doublereal *c__, integer *ldc, +	doublereal *work, integer *ldwork);+ +/* Subroutine */ int dlarfg_(integer *n, doublereal *alpha, doublereal *x, +	integer *incx, doublereal *tau);+ +/* Subroutine */ int dlarft_(char *direct, char *storev, integer *n, integer *+	k, doublereal *v, integer *ldv, doublereal *tau, doublereal *t, +	integer *ldt);+ +/* Subroutine */ int dlarfx_(char *side, integer *m, integer *n, doublereal *+	v, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work);+ +/* Subroutine */ int dlargv_(integer *n, doublereal *x, integer *incx, +	doublereal *y, integer *incy, doublereal *c__, integer *incc);+ +/* Subroutine */ int dlarnv_(integer *idist, integer *iseed, integer *n, +	doublereal *x);+ +/* Subroutine */ int dlarrb_(integer *n, doublereal *d__, doublereal *l, +	doublereal *ld, doublereal *lld, integer *ifirst, integer *ilast, +	doublereal *sigma, doublereal *reltol, doublereal *w, doublereal *+	wgap, doublereal *werr, doublereal *work, integer *iwork, integer *+	info);+ +/* Subroutine */ int dlarre_(integer *n, doublereal *d__, doublereal *e, +	doublereal *tol, integer *nsplit, integer *isplit, integer *m, +	doublereal *w, doublereal *woff, doublereal *gersch, doublereal *work,+	 integer *info);+ +/* Subroutine */ int dlarrf_(integer *n, doublereal *d__, doublereal *l, +	doublereal *ld, doublereal *lld, integer *ifirst, integer *ilast, +	doublereal *w, doublereal *dplus, doublereal *lplus, doublereal *work,+	 integer *iwork, integer *info);+ +/* Subroutine */ int dlarrv_(integer *n, doublereal *d__, doublereal *l, +	integer *isplit, integer *m, doublereal *w, integer *iblock, +	doublereal *gersch, doublereal *tol, doublereal *z__, integer *ldz, +	integer *isuppz, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dlartg_(doublereal *f, doublereal *g, doublereal *cs, +	doublereal *sn, doublereal *r__);+ +/* Subroutine */ int dlartv_(integer *n, doublereal *x, integer *incx, +	doublereal *y, integer *incy, doublereal *c__, doublereal *s, integer +	*incc);+ +/* Subroutine */ int dlaruv_(integer *iseed, integer *n, doublereal *x);+ +/* Subroutine */ int dlarz_(char *side, integer *m, integer *n, integer *l, +	doublereal *v, integer *incv, doublereal *tau, doublereal *c__, +	integer *ldc, doublereal *work);+ +/* Subroutine */ int dlarzb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, integer *l, doublereal *v,+	 integer *ldv, doublereal *t, integer *ldt, doublereal *c__, integer *+	ldc, doublereal *work, integer *ldwork);+ +/* Subroutine */ int dlarzt_(char *direct, char *storev, integer *n, integer *+	k, doublereal *v, integer *ldv, doublereal *tau, doublereal *t, +	integer *ldt);+ +/* Subroutine */ int dlas2_(doublereal *f, doublereal *g, doublereal *h__, +	doublereal *ssmin, doublereal *ssmax);+ +/* Subroutine */ int dlascl_(char *type__, integer *kl, integer *ku, +	doublereal *cfrom, doublereal *cto, integer *m, integer *n, +	doublereal *a, integer *lda, integer *info);+ +/* Subroutine */ int dlasd0_(integer *n, integer *sqre, doublereal *d__, +	doublereal *e, doublereal *u, integer *ldu, doublereal *vt, integer *+	ldvt, integer *smlsiz, integer *iwork, doublereal *work, integer *+	info);+ +/* Subroutine */ int dlasd1_(integer *nl, integer *nr, integer *sqre, +	doublereal *d__, doublereal *alpha, doublereal *beta, doublereal *u, +	integer *ldu, doublereal *vt, integer *ldvt, integer *idxq, integer *+	iwork, doublereal *work, integer *info);+ +/* Subroutine */ int dlasd2_(integer *nl, integer *nr, integer *sqre, integer +	*k, doublereal *d__, doublereal *z__, doublereal *alpha, doublereal *+	beta, doublereal *u, integer *ldu, doublereal *vt, integer *ldvt, +	doublereal *dsigma, doublereal *u2, integer *ldu2, doublereal *vt2, +	integer *ldvt2, integer *idxp, integer *idx, integer *idxc, integer *+	idxq, integer *coltyp, integer *info);+ +/* Subroutine */ int dlasd3_(integer *nl, integer *nr, integer *sqre, integer +	*k, doublereal *d__, doublereal *q, integer *ldq, doublereal *dsigma, +	doublereal *u, integer *ldu, doublereal *u2, integer *ldu2, +	doublereal *vt, integer *ldvt, doublereal *vt2, integer *ldvt2, +	integer *idxc, integer *ctot, doublereal *z__, integer *info);+ +/* Subroutine */ int dlasd4_(integer *n, integer *i__, doublereal *d__, +	doublereal *z__, doublereal *delta, doublereal *rho, doublereal *+	sigma, doublereal *work, integer *info);+ +/* Subroutine */ int dlasd5_(integer *i__, doublereal *d__, doublereal *z__, +	doublereal *delta, doublereal *rho, doublereal *dsigma, doublereal *+	work);+ +/* Subroutine */ int dlasd6_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, doublereal *d__, doublereal *vf, doublereal *vl, +	doublereal *alpha, doublereal *beta, integer *idxq, integer *perm, +	integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum,+	 integer *ldgnum, doublereal *poles, doublereal *difl, doublereal *+	difr, doublereal *z__, integer *k, doublereal *c__, doublereal *s, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dlasd7_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, integer *k, doublereal *d__, doublereal *z__, +	doublereal *zw, doublereal *vf, doublereal *vfw, doublereal *vl, +	doublereal *vlw, doublereal *alpha, doublereal *beta, doublereal *+	dsigma, integer *idx, integer *idxp, integer *idxq, integer *perm, +	integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum,+	 integer *ldgnum, doublereal *c__, doublereal *s, integer *info);+ +/* Subroutine */ int dlasd8_(integer *icompq, integer *k, doublereal *d__, +	doublereal *z__, doublereal *vf, doublereal *vl, doublereal *difl, +	doublereal *difr, integer *lddifr, doublereal *dsigma, doublereal *+	work, integer *info);+ +/* Subroutine */ int dlasd9_(integer *icompq, integer *ldu, integer *k, +	doublereal *d__, doublereal *z__, doublereal *vf, doublereal *vl, +	doublereal *difl, doublereal *difr, doublereal *dsigma, doublereal *+	work, integer *info);+ +/* Subroutine */ int dlasda_(integer *icompq, integer *smlsiz, integer *n, +	integer *sqre, doublereal *d__, doublereal *e, doublereal *u, integer +	*ldu, doublereal *vt, integer *k, doublereal *difl, doublereal *difr, +	doublereal *z__, doublereal *poles, integer *givptr, integer *givcol, +	integer *ldgcol, integer *perm, doublereal *givnum, doublereal *c__, +	doublereal *s, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dlasdq_(char *uplo, integer *sqre, integer *n, integer *+	ncvt, integer *nru, integer *ncc, doublereal *d__, doublereal *e, +	doublereal *vt, integer *ldvt, doublereal *u, integer *ldu, +	doublereal *c__, integer *ldc, doublereal *work, integer *info);+ +/* Subroutine */ int dlasdt_(integer *n, integer *lvl, integer *nd, integer *+	inode, integer *ndiml, integer *ndimr, integer *msub);+ +/* Subroutine */ int dlaset_(char *uplo, integer *m, integer *n, doublereal *+	alpha, doublereal *beta, doublereal *a, integer *lda);+ +/* Subroutine */ int dlasq1_(integer *n, doublereal *d__, doublereal *e, +	doublereal *work, integer *info);+ +/* Subroutine */ int dlasq2_(integer *n, doublereal *z__, integer *info);+ +/* Subroutine */ int dlasq3_(integer *i0, integer *n0, doublereal *z__, +	integer *pp, doublereal *dmin__, doublereal *sigma, doublereal *desig,+	 doublereal *qmax, integer *nfail, integer *iter, integer *ndiv, +	logical *ieee);+ +/* Subroutine */ int dlasq4_(integer *i0, integer *n0, doublereal *z__, +	integer *pp, integer *n0in, doublereal *dmin__, doublereal *dmin1, +	doublereal *dmin2, doublereal *dn, doublereal *dn1, doublereal *dn2, +	doublereal *tau, integer *ttype);+ +/* Subroutine */ int dlasq5_(integer *i0, integer *n0, doublereal *z__, +	integer *pp, doublereal *tau, doublereal *dmin__, doublereal *dmin1, +	doublereal *dmin2, doublereal *dn, doublereal *dnm1, doublereal *dnm2,+	 logical *ieee);+ +/* Subroutine */ int dlasq6_(integer *i0, integer *n0, doublereal *z__, +	integer *pp, doublereal *dmin__, doublereal *dmin1, doublereal *dmin2,+	 doublereal *dn, doublereal *dnm1, doublereal *dnm2);+ +/* Subroutine */ int dlasr_(char *side, char *pivot, char *direct, integer *m,+	 integer *n, doublereal *c__, doublereal *s, doublereal *a, integer *+	lda);+ +/* Subroutine */ int dlasrt_(char *id, integer *n, doublereal *d__, integer *+	info);+ +/* Subroutine */ int dlassq_(integer *n, doublereal *x, integer *incx, +	doublereal *scale, doublereal *sumsq);+ +/* Subroutine */ int dlasv2_(doublereal *f, doublereal *g, doublereal *h__, +	doublereal *ssmin, doublereal *ssmax, doublereal *snr, doublereal *+	csr, doublereal *snl, doublereal *csl);+ +/* Subroutine */ int dlaswp_(integer *n, doublereal *a, integer *lda, integer +	*k1, integer *k2, integer *ipiv, integer *incx);+ +/* Subroutine */ int dlasy2_(logical *ltranl, logical *ltranr, integer *isgn, +	integer *n1, integer *n2, doublereal *tl, integer *ldtl, doublereal *+	tr, integer *ldtr, doublereal *b, integer *ldb, doublereal *scale, +	doublereal *x, integer *ldx, doublereal *xnorm, integer *info);+ +/* Subroutine */ int dlasyf_(char *uplo, integer *n, integer *nb, integer *kb,+	 doublereal *a, integer *lda, integer *ipiv, doublereal *w, integer *+	ldw, integer *info);+ +/* Subroutine */ int dlatbs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, integer *kd, doublereal *ab, integer *ldab, +	doublereal *x, doublereal *scale, doublereal *cnorm, integer *info);+ +/* Subroutine */ int dlatdf_(integer *ijob, integer *n, doublereal *z__, +	integer *ldz, doublereal *rhs, doublereal *rdsum, doublereal *rdscal, +	integer *ipiv, integer *jpiv);+ +/* Subroutine */ int dlatps_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, doublereal *ap, doublereal *x, doublereal *scale, +	doublereal *cnorm, integer *info);+ +/* Subroutine */ int dlatrd_(char *uplo, integer *n, integer *nb, doublereal *+	a, integer *lda, doublereal *e, doublereal *tau, doublereal *w, +	integer *ldw);+ +/* Subroutine */ int dlatrs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, doublereal *a, integer *lda, doublereal *x, +	doublereal *scale, doublereal *cnorm, integer *info);+ +/* Subroutine */ int dlatrz_(integer *m, integer *n, integer *l, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work);+ +/* Subroutine */ int dlatzm_(char *side, integer *m, integer *n, doublereal *+	v, integer *incv, doublereal *tau, doublereal *c1, doublereal *c2, +	integer *ldc, doublereal *work);+ +/* Subroutine */ int dlauu2_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *info);+ +/* Subroutine */ int dlauum_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *info);+ +/* Subroutine */ int dopgtr_(char *uplo, integer *n, doublereal *ap, +	doublereal *tau, doublereal *q, integer *ldq, doublereal *work, +	integer *info);+ +/* Subroutine */ int dopmtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, doublereal *ap, doublereal *tau, doublereal *c__, integer +	*ldc, doublereal *work, integer *info);+ +/* Subroutine */ int dorg2l_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dorg2r_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dorgbr_(char *vect, integer *m, integer *n, integer *k, +	doublereal *a, integer *lda, doublereal *tau, doublereal *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int dorghr_(integer *n, integer *ilo, integer *ihi, +	doublereal *a, integer *lda, doublereal *tau, doublereal *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int dorgl2_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dorglq_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dorgql_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dorgqr_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dorgr2_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *info);+ +/* Subroutine */ int dorgrq_(integer *m, integer *n, integer *k, doublereal *+	a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dorgtr_(char *uplo, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dorm2l_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *info);+ +/* Subroutine */ int dorm2r_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *info);+ +/* Subroutine */ int dormbr_(char *vect, char *side, char *trans, integer *m, +	integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, +	doublereal *c__, integer *ldc, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dormhr_(char *side, char *trans, integer *m, integer *n, +	integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal *+	tau, doublereal *c__, integer *ldc, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dorml2_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *info);+ +/* Subroutine */ int dormlq_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dormql_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dormqr_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dormr2_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *info);+ +/* Subroutine */ int dormr3_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, doublereal *a, integer *lda, doublereal *tau, +	doublereal *c__, integer *ldc, doublereal *work, integer *info);+ +/* Subroutine */ int dormrq_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dormrz_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, doublereal *a, integer *lda, doublereal *tau, +	doublereal *c__, integer *ldc, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dormtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, doublereal *a, integer *lda, doublereal *tau, doublereal *+	c__, integer *ldc, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dpbcon_(char *uplo, integer *n, integer *kd, doublereal *+	ab, integer *ldab, doublereal *anorm, doublereal *rcond, doublereal *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int dpbequ_(char *uplo, integer *n, integer *kd, doublereal *+	ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax,+	 integer *info);+ +/* Subroutine */ int dpbrfs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, +	doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *+	ferr, doublereal *berr, doublereal *work, integer *iwork, integer *+	info);+ +/* Subroutine */ int dpbstf_(char *uplo, integer *n, integer *kd, doublereal *+	ab, integer *ldab, integer *info);+ +/* Subroutine */ int dpbsv_(char *uplo, integer *n, integer *kd, integer *+	nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int dpbsvx_(char *fact, char *uplo, integer *n, integer *kd, +	integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, +	integer *ldafb, char *equed, doublereal *s, doublereal *b, integer *+	ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *ferr,+	 doublereal *berr, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dpbtf2_(char *uplo, integer *n, integer *kd, doublereal *+	ab, integer *ldab, integer *info);+ +/* Subroutine */ int dpbtrf_(char *uplo, integer *n, integer *kd, doublereal *+	ab, integer *ldab, integer *info);+ +/* Subroutine */ int dpbtrs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int dpocon_(char *uplo, integer *n, doublereal *a, integer *+	lda, doublereal *anorm, doublereal *rcond, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dpoequ_(integer *n, doublereal *a, integer *lda, +	doublereal *s, doublereal *scond, doublereal *amax, integer *info);+ +/* Subroutine */ int dporfs_(char *uplo, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *af, integer *ldaf, +	doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *+	ferr, doublereal *berr, doublereal *work, integer *iwork, integer *+	info);+ +/* Subroutine */ int dposv_(char *uplo, integer *n, integer *nrhs, doublereal +	*a, integer *lda, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dposvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, +	char *equed, doublereal *s, doublereal *b, integer *ldb, doublereal *+	x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *+	berr, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dpotf2_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *info);+ +/* Subroutine */ int dpotrf_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *info);+ +/* Subroutine */ int dpotri_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *info);+ +/* Subroutine */ int dpotrs_(char *uplo, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int dppcon_(char *uplo, integer *n, doublereal *ap, +	doublereal *anorm, doublereal *rcond, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dppequ_(char *uplo, integer *n, doublereal *ap, +	doublereal *s, doublereal *scond, doublereal *amax, integer *info);+ +/* Subroutine */ int dpprfs_(char *uplo, integer *n, integer *nrhs, +	doublereal *ap, doublereal *afp, doublereal *b, integer *ldb, +	doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dppsv_(char *uplo, integer *n, integer *nrhs, doublereal +	*ap, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dppsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublereal *ap, doublereal *afp, char *equed, doublereal *s, +	doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *+	rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int dpptrf_(char *uplo, integer *n, doublereal *ap, integer *+	info);+ +/* Subroutine */ int dpptri_(char *uplo, integer *n, doublereal *ap, integer *+	info);+ +/* Subroutine */ int dpptrs_(char *uplo, integer *n, integer *nrhs, +	doublereal *ap, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dptcon_(integer *n, doublereal *d__, doublereal *e, +	doublereal *anorm, doublereal *rcond, doublereal *work, integer *info);+ +/* Subroutine */ int dpteqr_(char *compz, integer *n, doublereal *d__, +	doublereal *e, doublereal *z__, integer *ldz, doublereal *work, +	integer *info);+ +/* Subroutine */ int dptrfs_(integer *n, integer *nrhs, doublereal *d__, +	doublereal *e, doublereal *df, doublereal *ef, doublereal *b, integer +	*ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr,+	 doublereal *work, integer *info);+ +/* Subroutine */ int dptsv_(integer *n, integer *nrhs, doublereal *d__, +	doublereal *e, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dptsvx_(char *fact, integer *n, integer *nrhs, +	doublereal *d__, doublereal *e, doublereal *df, doublereal *ef, +	doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *+	rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *+	info);+ +/* Subroutine */ int dpttrf_(integer *n, doublereal *d__, doublereal *e, +	integer *info);+ +/* Subroutine */ int dpttrs_(integer *n, integer *nrhs, doublereal *d__, +	doublereal *e, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dptts2_(integer *n, integer *nrhs, doublereal *d__, +	doublereal *e, doublereal *b, integer *ldb);+ +/* Subroutine */ int drscl_(integer *n, doublereal *sa, doublereal *sx, +	integer *incx);+ +/* Subroutine */ int dsbev_(char *jobz, char *uplo, integer *n, integer *kd, +	doublereal *ab, integer *ldab, doublereal *w, doublereal *z__, +	integer *ldz, doublereal *work, integer *info);+ +/* Subroutine */ int dsbevd_(char *jobz, char *uplo, integer *n, integer *kd, +	doublereal *ab, integer *ldab, doublereal *w, doublereal *z__, +	integer *ldz, doublereal *work, integer *lwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int dsbevx_(char *jobz, char *range, char *uplo, integer *n, +	integer *kd, doublereal *ab, integer *ldab, doublereal *q, integer *+	ldq, doublereal *vl, doublereal *vu, integer *il, integer *iu, +	doublereal *abstol, integer *m, doublereal *w, doublereal *z__, +	integer *ldz, doublereal *work, integer *iwork, integer *ifail, +	integer *info);+ +/* Subroutine */ int dsbgst_(char *vect, char *uplo, integer *n, integer *ka, +	integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer *+	ldbb, doublereal *x, integer *ldx, doublereal *work, integer *info);+ +/* Subroutine */ int dsbgv_(char *jobz, char *uplo, integer *n, integer *ka, +	integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer *+	ldbb, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, +	integer *info);+ +/* Subroutine */ int dsbgvd_(char *jobz, char *uplo, integer *n, integer *ka, +	integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer *+	ldbb, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dsbgvx_(char *jobz, char *range, char *uplo, integer *n, +	integer *ka, integer *kb, doublereal *ab, integer *ldab, doublereal *+	bb, integer *ldbb, doublereal *q, integer *ldq, doublereal *vl, +	doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer +	*m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, +	integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int dsbtrd_(char *vect, char *uplo, integer *n, integer *kd, +	doublereal *ab, integer *ldab, doublereal *d__, doublereal *e, +	doublereal *q, integer *ldq, doublereal *work, integer *info);+ +/* Subroutine */ int dspcon_(char *uplo, integer *n, doublereal *ap, integer *+	ipiv, doublereal *anorm, doublereal *rcond, doublereal *work, integer +	*iwork, integer *info);+ +/* Subroutine */ int dspev_(char *jobz, char *uplo, integer *n, doublereal *+	ap, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, +	integer *info);+ +/* Subroutine */ int dspevd_(char *jobz, char *uplo, integer *n, doublereal *+	ap, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dspevx_(char *jobz, char *range, char *uplo, integer *n, +	doublereal *ap, doublereal *vl, doublereal *vu, integer *il, integer *+	iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, +	integer *ldz, doublereal *work, integer *iwork, integer *ifail, +	integer *info);+ +/* Subroutine */ int dspgst_(integer *itype, char *uplo, integer *n, +	doublereal *ap, doublereal *bp, integer *info);+ +/* Subroutine */ int dspgv_(integer *itype, char *jobz, char *uplo, integer *+	n, doublereal *ap, doublereal *bp, doublereal *w, doublereal *z__, +	integer *ldz, doublereal *work, integer *info);+ +/* Subroutine */ int dspgvd_(integer *itype, char *jobz, char *uplo, integer *+	n, doublereal *ap, doublereal *bp, doublereal *w, doublereal *z__, +	integer *ldz, doublereal *work, integer *lwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int dspgvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, doublereal *ap, doublereal *bp, doublereal *vl, +	doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer +	*m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, +	integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int dsprfs_(char *uplo, integer *n, integer *nrhs, +	doublereal *ap, doublereal *afp, integer *ipiv, doublereal *b, +	integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, +	doublereal *berr, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dspsv_(char *uplo, integer *n, integer *nrhs, doublereal +	*ap, integer *ipiv, doublereal *b, integer *ldb, integer *info);+ +/* Subroutine */ int dspsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublereal *ap, doublereal *afp, integer *ipiv, doublereal *b, +	integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, +	doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dsptrd_(char *uplo, integer *n, doublereal *ap, +	doublereal *d__, doublereal *e, doublereal *tau, integer *info);+ +/* Subroutine */ int dsptrf_(char *uplo, integer *n, doublereal *ap, integer *+	ipiv, integer *info);+ +/* Subroutine */ int dsptri_(char *uplo, integer *n, doublereal *ap, integer *+	ipiv, doublereal *work, integer *info);+ +/* Subroutine */ int dsptrs_(char *uplo, integer *n, integer *nrhs, +	doublereal *ap, integer *ipiv, doublereal *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int dstebz_(char *range, char *order, integer *n, doublereal +	*vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, +	doublereal *d__, doublereal *e, integer *m, integer *nsplit, +	doublereal *w, integer *iblock, integer *isplit, doublereal *work, +	integer *iwork, integer *info);+ +/* Subroutine */ int dstedc_(char *compz, integer *n, doublereal *d__, +	doublereal *e, doublereal *z__, integer *ldz, doublereal *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dstegr_(char *jobz, char *range, integer *n, doublereal *+	d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, +	integer *iu, doublereal *abstol, integer *m, doublereal *w, +	doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dstein_(integer *n, doublereal *d__, doublereal *e, +	integer *m, doublereal *w, integer *iblock, integer *isplit, +	doublereal *z__, integer *ldz, doublereal *work, integer *iwork, +	integer *ifail, integer *info);+ +/* Subroutine */ int dsteqr_(char *compz, integer *n, doublereal *d__, +	doublereal *e, doublereal *z__, integer *ldz, doublereal *work, +	integer *info);+ +/* Subroutine */ int dsterf_(integer *n, doublereal *d__, doublereal *e, +	integer *info);+ +/* Subroutine */ int dstev_(char *jobz, integer *n, doublereal *d__, +	doublereal *e, doublereal *z__, integer *ldz, doublereal *work, +	integer *info);+ +/* Subroutine */ int dstevd_(char *jobz, integer *n, doublereal *d__, +	doublereal *e, doublereal *z__, integer *ldz, doublereal *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dstevr_(char *jobz, char *range, integer *n, doublereal *+	d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, +	integer *iu, doublereal *abstol, integer *m, doublereal *w, +	doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dstevx_(char *jobz, char *range, integer *n, doublereal *+	d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, +	integer *iu, doublereal *abstol, integer *m, doublereal *w, +	doublereal *z__, integer *ldz, doublereal *work, integer *iwork, +	integer *ifail, integer *info);+ +/* Subroutine */ int dsycon_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *ipiv, doublereal *anorm, doublereal *rcond, doublereal *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int dsyev_(char *jobz, char *uplo, integer *n, doublereal *a,+	 integer *lda, doublereal *w, doublereal *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int dsyevd_(char *jobz, char *uplo, integer *n, doublereal *+	a, integer *lda, doublereal *w, doublereal *work, integer *lwork, +	integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dsyevr_(char *jobz, char *range, char *uplo, integer *n, +	doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer *+	il, integer *iu, doublereal *abstol, integer *m, doublereal *w, +	doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int dsyevx_(char *jobz, char *range, char *uplo, integer *n, +	doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer *+	il, integer *iu, doublereal *abstol, integer *m, doublereal *w, +	doublereal *z__, integer *ldz, doublereal *work, integer *lwork, +	integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int dsygs2_(integer *itype, char *uplo, integer *n, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int dsygst_(integer *itype, char *uplo, integer *n, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int dsygv_(integer *itype, char *jobz, char *uplo, integer *+	n, doublereal *a, integer *lda, doublereal *b, integer *ldb, +	doublereal *w, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dsygvd_(integer *itype, char *jobz, char *uplo, integer *+	n, doublereal *a, integer *lda, doublereal *b, integer *ldb, +	doublereal *w, doublereal *work, integer *lwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int dsygvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, doublereal *a, integer *lda, doublereal *b, integer +	*ldb, doublereal *vl, doublereal *vu, integer *il, integer *iu, +	doublereal *abstol, integer *m, doublereal *w, doublereal *z__, +	integer *ldz, doublereal *work, integer *lwork, integer *iwork, +	integer *ifail, integer *info);+ +/* Subroutine */ int dsyrfs_(char *uplo, integer *n, integer *nrhs, +	doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *+	ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, +	doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dsysv_(char *uplo, integer *n, integer *nrhs, doublereal +	*a, integer *lda, integer *ipiv, doublereal *b, integer *ldb, +	doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dsysvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, +	integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer *+	ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, +	doublereal *work, integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int dsytd2_(char *uplo, integer *n, doublereal *a, integer *+	lda, doublereal *d__, doublereal *e, doublereal *tau, integer *info);+ +/* Subroutine */ int dsytf2_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *ipiv, integer *info);+ +/* Subroutine */ int dsytrd_(char *uplo, integer *n, doublereal *a, integer *+	lda, doublereal *d__, doublereal *e, doublereal *tau, doublereal *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int dsytrf_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *ipiv, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dsytri_(char *uplo, integer *n, doublereal *a, integer *+	lda, integer *ipiv, doublereal *work, integer *info);+ +/* Subroutine */ int dsytrs_(char *uplo, integer *n, integer *nrhs, +	doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *+	ldb, integer *info);+ +/* Subroutine */ int dtbcon_(char *norm, char *uplo, char *diag, integer *n, +	integer *kd, doublereal *ab, integer *ldab, doublereal *rcond, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dtbrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, doublereal *ab, integer *ldab, doublereal +	*b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, +	doublereal *berr, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dtbtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, doublereal *ab, integer *ldab, doublereal +	*b, integer *ldb, integer *info);+ +/* Subroutine */ int dtgevc_(char *side, char *howmny, logical *select, +	integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, +	doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, integer +	*mm, integer *m, doublereal *work, integer *info);+ +/* Subroutine */ int dtgex2_(logical *wantq, logical *wantz, integer *n, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *+	q, integer *ldq, doublereal *z__, integer *ldz, integer *j1, integer *+	n1, integer *n2, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dtgexc_(logical *wantq, logical *wantz, integer *n, +	doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *+	q, integer *ldq, doublereal *z__, integer *ldz, integer *ifst, +	integer *ilst, doublereal *work, integer *lwork, integer *info);+ +/* Subroutine */ int dtgsen_(integer *ijob, logical *wantq, logical *wantz, +	logical *select, integer *n, doublereal *a, integer *lda, doublereal *+	b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *+	beta, doublereal *q, integer *ldq, doublereal *z__, integer *ldz, +	integer *m, doublereal *pl, doublereal *pr, doublereal *dif, +	doublereal *work, integer *lwork, integer *iwork, integer *liwork, +	integer *info);+ +/* Subroutine */ int dtgsja_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, integer *k, integer *l, doublereal *a, +	integer *lda, doublereal *b, integer *ldb, doublereal *tola, +	doublereal *tolb, doublereal *alpha, doublereal *beta, doublereal *u, +	integer *ldu, doublereal *v, integer *ldv, doublereal *q, integer *+	ldq, doublereal *work, integer *ncycle, integer *info);+ +/* Subroutine */ int dtgsna_(char *job, char *howmny, logical *select, +	integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, +	doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, +	doublereal *s, doublereal *dif, integer *mm, integer *m, doublereal *+	work, integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int dtgsy2_(char *trans, integer *ijob, integer *m, integer *+	n, doublereal *a, integer *lda, doublereal *b, integer *ldb, +	doublereal *c__, integer *ldc, doublereal *d__, integer *ldd, +	doublereal *e, integer *lde, doublereal *f, integer *ldf, doublereal *+	scale, doublereal *rdsum, doublereal *rdscal, integer *iwork, integer +	*pq, integer *info);+ +/* Subroutine */ int dtgsyl_(char *trans, integer *ijob, integer *m, integer *+	n, doublereal *a, integer *lda, doublereal *b, integer *ldb, +	doublereal *c__, integer *ldc, doublereal *d__, integer *ldd, +	doublereal *e, integer *lde, doublereal *f, integer *ldf, doublereal *+	scale, doublereal *dif, doublereal *work, integer *lwork, integer *+	iwork, integer *info);+ +/* Subroutine */ int dtpcon_(char *norm, char *uplo, char *diag, integer *n, +	doublereal *ap, doublereal *rcond, doublereal *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int dtprfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, +	doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dtptri_(char *uplo, char *diag, integer *n, doublereal *+	ap, integer *info);+ +/* Subroutine */ int dtptrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int dtrcon_(char *norm, char *uplo, char *diag, integer *n, +	doublereal *a, integer *lda, doublereal *rcond, doublereal *work, +	integer *iwork, integer *info);+ +/* Subroutine */ int dtrevc_(char *side, char *howmny, logical *select, +	integer *n, doublereal *t, integer *ldt, doublereal *vl, integer *+	ldvl, doublereal *vr, integer *ldvr, integer *mm, integer *m, +	doublereal *work, integer *info);+ +/* Subroutine */ int dtrexc_(char *compq, integer *n, doublereal *t, integer *+	ldt, doublereal *q, integer *ldq, integer *ifst, integer *ilst, +	doublereal *work, integer *info);+ +/* Subroutine */ int dtrrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *+	ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int dtrsen_(char *job, char *compq, logical *select, integer +	*n, doublereal *t, integer *ldt, doublereal *q, integer *ldq, +	doublereal *wr, doublereal *wi, integer *m, doublereal *s, doublereal +	*sep, doublereal *work, integer *lwork, integer *iwork, integer *+	liwork, integer *info);+ +/* Subroutine */ int dtrsna_(char *job, char *howmny, logical *select, +	integer *n, doublereal *t, integer *ldt, doublereal *vl, integer *+	ldvl, doublereal *vr, integer *ldvr, doublereal *s, doublereal *sep, +	integer *mm, integer *m, doublereal *work, integer *ldwork, integer *+	iwork, integer *info);+ +/* Subroutine */ int dtrsyl_(char *trana, char *tranb, integer *isgn, integer +	*m, integer *n, doublereal *a, integer *lda, doublereal *b, integer *+	ldb, doublereal *c__, integer *ldc, doublereal *scale, integer *info);+ +/* Subroutine */ int dtrti2_(char *uplo, char *diag, integer *n, doublereal *+	a, integer *lda, integer *info);+ +/* Subroutine */ int dtrtri_(char *uplo, char *diag, integer *n, doublereal *+	a, integer *lda, integer *info);+ +/* Subroutine */ int dtrtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *+	ldb, integer *info);+ +/* Subroutine */ int dtzrqf_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, integer *info);+ +/* Subroutine */ int dtzrzf_(integer *m, integer *n, doublereal *a, integer *+	lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);+ +integer icmax1_(integer *n, complex *cx, integer *incx);+ +integer ieeeck_(integer *ispec, real *zero, real *one);+ +integer ilaenv_(integer *ispec, char *name__, char *opts, integer *n1, +	integer *n2, integer *n3, integer *n4, ftnlen name_len, ftnlen +	opts_len);+ +integer izmax1_(integer *n, doublecomplex *cx, integer *incx);+ +/* Subroutine */ int sbdsdc_(char *uplo, char *compq, integer *n, real *d__, +	real *e, real *u, integer *ldu, real *vt, integer *ldvt, real *q, +	integer *iq, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sbdsqr_(char *uplo, integer *n, integer *ncvt, integer *+	nru, integer *ncc, real *d__, real *e, real *vt, integer *ldvt, real *+	u, integer *ldu, real *c__, integer *ldc, real *work, integer *info);+ +/* Subroutine */ int sdisna_(char *job, integer *m, integer *n, real *d__, +	real *sep, integer *info);+ +/* Subroutine */ int sgbbrd_(char *vect, integer *m, integer *n, integer *ncc,+	 integer *kl, integer *ku, real *ab, integer *ldab, real *d__, real *+	e, real *q, integer *ldq, real *pt, integer *ldpt, real *c__, integer +	*ldc, real *work, integer *info);+ +/* Subroutine */ int sgbcon_(char *norm, integer *n, integer *kl, integer *ku,+	 real *ab, integer *ldab, integer *ipiv, real *anorm, real *rcond, +	real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sgbequ_(integer *m, integer *n, integer *kl, integer *ku,+	 real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *+	colcnd, real *amax, integer *info);+ +/* Subroutine */ int sgbrfs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb,+	 integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *+	ferr, real *berr, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sgbsv_(integer *n, integer *kl, integer *ku, integer *+	nrhs, real *ab, integer *ldab, integer *ipiv, real *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int sgbsvx_(char *fact, char *trans, integer *n, integer *kl,+	 integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, +	integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, +	real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr,+	 real *berr, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sgbtf2_(integer *m, integer *n, integer *kl, integer *ku,+	 real *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int sgbtrf_(integer *m, integer *n, integer *kl, integer *ku,+	 real *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int sgbtrs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, real *ab, integer *ldab, integer *ipiv, real *b, +	integer *ldb, integer *info);+ +/* Subroutine */ int sgebak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, real *scale, integer *m, real *v, integer *ldv, integer +	*info);+ +/* Subroutine */ int sgebal_(char *job, integer *n, real *a, integer *lda, +	integer *ilo, integer *ihi, real *scale, integer *info);+ +/* Subroutine */ int sgebd2_(integer *m, integer *n, real *a, integer *lda, +	real *d__, real *e, real *tauq, real *taup, real *work, integer *info);+ +/* Subroutine */ int sgebrd_(integer *m, integer *n, real *a, integer *lda, +	real *d__, real *e, real *tauq, real *taup, real *work, integer *+	lwork, integer *info);+ +/* Subroutine */ int sgecon_(char *norm, integer *n, real *a, integer *lda, +	real *anorm, real *rcond, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sgeequ_(integer *m, integer *n, real *a, integer *lda, +	real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer +	*info);+ +/* Subroutine */ int sgees_(char *jobvs, char *sort, L_fp select, integer *n, +	real *a, integer *lda, integer *sdim, real *wr, real *wi, real *vs, +	integer *ldvs, real *work, integer *lwork, logical *bwork, integer *+	info);+ +/* Subroutine */ int sgeesx_(char *jobvs, char *sort, L_fp select, char *+	sense, integer *n, real *a, integer *lda, integer *sdim, real *wr, +	real *wi, real *vs, integer *ldvs, real *rconde, real *rcondv, real *+	work, integer *lwork, integer *iwork, integer *liwork, logical *bwork,+	 integer *info);+ +/* Subroutine */ int sgeev_(char *jobvl, char *jobvr, integer *n, real *a, +	integer *lda, real *wr, real *wi, real *vl, integer *ldvl, real *vr, +	integer *ldvr, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgeevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, real *a, integer *lda, real *wr, real *wi, real *+	vl, integer *ldvl, real *vr, integer *ldvr, integer *ilo, integer *+	ihi, real *scale, real *abnrm, real *rconde, real *rcondv, real *work,+	 integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int sgegs_(char *jobvsl, char *jobvsr, integer *n, real *a, +	integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real +	*beta, real *vsl, integer *ldvsl, real *vsr, integer *ldvsr, real *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int sgegv_(char *jobvl, char *jobvr, integer *n, real *a, +	integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real +	*beta, real *vl, integer *ldvl, real *vr, integer *ldvr, real *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int sgehd2_(integer *n, integer *ilo, integer *ihi, real *a, +	integer *lda, real *tau, real *work, integer *info);+ +/* Subroutine */ int sgehrd_(integer *n, integer *ilo, integer *ihi, real *a, +	integer *lda, real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgelq2_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *info);+ +/* Subroutine */ int sgelqf_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgels_(char *trans, integer *m, integer *n, integer *+	nrhs, real *a, integer *lda, real *b, integer *ldb, real *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int sgelsd_(integer *m, integer *n, integer *nrhs, real *a, +	integer *lda, real *b, integer *ldb, real *s, real *rcond, integer *+	rank, real *work, integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int sgelss_(integer *m, integer *n, integer *nrhs, real *a, +	integer *lda, real *b, integer *ldb, real *s, real *rcond, integer *+	rank, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgelsx_(integer *m, integer *n, integer *nrhs, real *a, +	integer *lda, real *b, integer *ldb, integer *jpvt, real *rcond, +	integer *rank, real *work, integer *info);+ +/* Subroutine */ int sgelsy_(integer *m, integer *n, integer *nrhs, real *a, +	integer *lda, real *b, integer *ldb, integer *jpvt, real *rcond, +	integer *rank, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgeql2_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *info);+ +/* Subroutine */ int sgeqlf_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgeqp3_(integer *m, integer *n, real *a, integer *lda, +	integer *jpvt, real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgeqpf_(integer *m, integer *n, real *a, integer *lda, +	integer *jpvt, real *tau, real *work, integer *info);+ +/* Subroutine */ int sgeqr2_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *info);+ +/* Subroutine */ int sgeqrf_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgerfs_(char *trans, integer *n, integer *nrhs, real *a, +	integer *lda, real *af, integer *ldaf, integer *ipiv, real *b, +	integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int sgerq2_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *info);+ +/* Subroutine */ int sgerqf_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgesc2_(integer *n, real *a, integer *lda, real *rhs, +	integer *ipiv, integer *jpiv, real *scale);+ +/* Subroutine */ int sgesdd_(char *jobz, integer *m, integer *n, real *a, +	integer *lda, real *s, real *u, integer *ldu, real *vt, integer *ldvt,+	 real *work, integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int sgesv_(integer *n, integer *nrhs, real *a, integer *lda, +	integer *ipiv, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sgesvd_(char *jobu, char *jobvt, integer *m, integer *n, +	real *a, integer *lda, real *s, real *u, integer *ldu, real *vt, +	integer *ldvt, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgesvx_(char *fact, char *trans, integer *n, integer *+	nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, +	char *equed, real *r__, real *c__, real *b, integer *ldb, real *x, +	integer *ldx, real *rcond, real *ferr, real *berr, real *work, +	integer *iwork, integer *info);+ +/* Subroutine */ int sgetc2_(integer *n, real *a, integer *lda, integer *ipiv,+	 integer *jpiv, integer *info);+ +/* Subroutine */ int sgetf2_(integer *m, integer *n, real *a, integer *lda, +	integer *ipiv, integer *info);+ +/* Subroutine */ int sgetrf_(integer *m, integer *n, real *a, integer *lda, +	integer *ipiv, integer *info);+ +/* Subroutine */ int sgetri_(integer *n, real *a, integer *lda, integer *ipiv,+	 real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgetrs_(char *trans, integer *n, integer *nrhs, real *a, +	integer *lda, integer *ipiv, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sggbak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, real *lscale, real *rscale, integer *m, real *v, +	integer *ldv, integer *info);+ +/* Subroutine */ int sggbal_(char *job, integer *n, real *a, integer *lda, +	real *b, integer *ldb, integer *ilo, integer *ihi, real *lscale, real +	*rscale, real *work, integer *info);+ +/* Subroutine */ int sgges_(char *jobvsl, char *jobvsr, char *sort, L_fp +	selctg, integer *n, real *a, integer *lda, real *b, integer *ldb, +	integer *sdim, real *alphar, real *alphai, real *beta, real *vsl, +	integer *ldvsl, real *vsr, integer *ldvsr, real *work, integer *lwork,+	 logical *bwork, integer *info);+ +/* Subroutine */ int sggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp +	selctg, char *sense, integer *n, real *a, integer *lda, real *b, +	integer *ldb, integer *sdim, real *alphar, real *alphai, real *beta, +	real *vsl, integer *ldvsl, real *vsr, integer *ldvsr, real *rconde, +	real *rcondv, real *work, integer *lwork, integer *iwork, integer *+	liwork, logical *bwork, integer *info);+ +/* Subroutine */ int sggev_(char *jobvl, char *jobvr, integer *n, real *a, +	integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real +	*beta, real *vl, integer *ldvl, real *vr, integer *ldvr, real *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int sggevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, real *a, integer *lda, real *b, integer *ldb, real +	*alphar, real *alphai, real *beta, real *vl, integer *ldvl, real *vr, +	integer *ldvr, integer *ilo, integer *ihi, real *lscale, real *rscale,+	 real *abnrm, real *bbnrm, real *rconde, real *rcondv, real *work, +	integer *lwork, integer *iwork, logical *bwork, integer *info);+ +/* Subroutine */ int sggglm_(integer *n, integer *m, integer *p, real *a, +	integer *lda, real *b, integer *ldb, real *d__, real *x, real *y, +	real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sgghrd_(char *compq, char *compz, integer *n, integer *+	ilo, integer *ihi, real *a, integer *lda, real *b, integer *ldb, real +	*q, integer *ldq, real *z__, integer *ldz, integer *info);+ +/* Subroutine */ int sgglse_(integer *m, integer *n, integer *p, real *a, +	integer *lda, real *b, integer *ldb, real *c__, real *d__, real *x, +	real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sggqrf_(integer *n, integer *m, integer *p, real *a, +	integer *lda, real *taua, real *b, integer *ldb, real *taub, real *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int sggrqf_(integer *m, integer *p, integer *n, real *a, +	integer *lda, real *taua, real *b, integer *ldb, real *taub, real *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int sggsvd_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *n, integer *p, integer *k, integer *l, real *a, integer *lda,+	 real *b, integer *ldb, real *alpha, real *beta, real *u, integer *+	ldu, real *v, integer *ldv, real *q, integer *ldq, real *work, +	integer *iwork, integer *info);+ +/* Subroutine */ int sggsvp_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, real *a, integer *lda, real *b, integer *ldb, +	real *tola, real *tolb, integer *k, integer *l, real *u, integer *ldu,+	 real *v, integer *ldv, real *q, integer *ldq, integer *iwork, real *+	tau, real *work, integer *info);+ +/* Subroutine */ int sgtcon_(char *norm, integer *n, real *dl, real *d__, +	real *du, real *du2, integer *ipiv, real *anorm, real *rcond, real *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int sgtrfs_(char *trans, integer *n, integer *nrhs, real *dl,+	 real *d__, real *du, real *dlf, real *df, real *duf, real *du2, +	integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *+	ferr, real *berr, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sgtsv_(integer *n, integer *nrhs, real *dl, real *d__, +	real *du, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sgtsvx_(char *fact, char *trans, integer *n, integer *+	nrhs, real *dl, real *d__, real *du, real *dlf, real *df, real *duf, +	real *du2, integer *ipiv, real *b, integer *ldb, real *x, integer *+	ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int sgttrf_(integer *n, real *dl, real *d__, real *du, real *+	du2, integer *ipiv, integer *info);+ +/* Subroutine */ int sgttrs_(char *trans, integer *n, integer *nrhs, real *dl,+	 real *d__, real *du, real *du2, integer *ipiv, real *b, integer *ldb,+	 integer *info);+ +/* Subroutine */ int sgtts2_(integer *itrans, integer *n, integer *nrhs, real +	*dl, real *d__, real *du, real *du2, integer *ipiv, real *b, integer *+	ldb);+ +/* Subroutine */ int shgeqz_(char *job, char *compq, char *compz, integer *n, +	integer *ilo, integer *ihi, real *a, integer *lda, real *b, integer *+	ldb, real *alphar, real *alphai, real *beta, real *q, integer *ldq, +	real *z__, integer *ldz, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int shsein_(char *side, char *eigsrc, char *initv, logical *+	select, integer *n, real *h__, integer *ldh, real *wr, real *wi, real +	*vl, integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, +	real *work, integer *ifaill, integer *ifailr, integer *info);+ +/* Subroutine */ int shseqr_(char *job, char *compz, integer *n, integer *ilo,+	 integer *ihi, real *h__, integer *ldh, real *wr, real *wi, real *z__,+	 integer *ldz, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int slabad_(real *small, real *large);+ +/* Subroutine */ int slabrd_(integer *m, integer *n, integer *nb, real *a, +	integer *lda, real *d__, real *e, real *tauq, real *taup, real *x, +	integer *ldx, real *y, integer *ldy);+ +/* Subroutine */ int slacon_(integer *n, real *v, real *x, integer *isgn, +	real *est, integer *kase);+ +/* Subroutine */ int slacpy_(char *uplo, integer *m, integer *n, real *a, +	integer *lda, real *b, integer *ldb);+ +/* Subroutine */ int sladiv_(real *a, real *b, real *c__, real *d__, real *p, +	real *q);+ +/* Subroutine */ int slae2_(real *a, real *b, real *c__, real *rt1, real *rt2);+ +/* Subroutine */ int slaebz_(integer *ijob, integer *nitmax, integer *n, +	integer *mmax, integer *minp, integer *nbmin, real *abstol, real *+	reltol, real *pivmin, real *d__, real *e, real *e2, integer *nval, +	real *ab, real *c__, integer *mout, integer *nab, real *work, integer +	*iwork, integer *info);+ +/* Subroutine */ int slaed0_(integer *icompq, integer *qsiz, integer *n, real +	*d__, real *e, real *q, integer *ldq, real *qstore, integer *ldqs, +	real *work, integer *iwork, integer *info);+ +/* Subroutine */ int slaed1_(integer *n, real *d__, real *q, integer *ldq, +	integer *indxq, real *rho, integer *cutpnt, real *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int slaed2_(integer *k, integer *n, integer *n1, real *d__, +	real *q, integer *ldq, integer *indxq, real *rho, real *z__, real *+	dlamda, real *w, real *q2, integer *indx, integer *indxc, integer *+	indxp, integer *coltyp, integer *info);+ +/* Subroutine */ int slaed3_(integer *k, integer *n, integer *n1, real *d__, +	real *q, integer *ldq, real *rho, real *dlamda, real *q2, integer *+	indx, integer *ctot, real *w, real *s, integer *info);+ +/* Subroutine */ int slaed4_(integer *n, integer *i__, real *d__, real *z__, +	real *delta, real *rho, real *dlam, integer *info);+ +/* Subroutine */ int slaed5_(integer *i__, real *d__, real *z__, real *delta, +	real *rho, real *dlam);+ +/* Subroutine */ int slaed6_(integer *kniter, logical *orgati, real *rho, +	real *d__, real *z__, real *finit, real *tau, integer *info);+ +/* Subroutine */ int slaed7_(integer *icompq, integer *n, integer *qsiz, +	integer *tlvls, integer *curlvl, integer *curpbm, real *d__, real *q, +	integer *ldq, integer *indxq, real *rho, integer *cutpnt, real *+	qstore, integer *qptr, integer *prmptr, integer *perm, integer *+	givptr, integer *givcol, real *givnum, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int slaed8_(integer *icompq, integer *k, integer *n, integer +	*qsiz, real *d__, real *q, integer *ldq, integer *indxq, real *rho, +	integer *cutpnt, real *z__, real *dlamda, real *q2, integer *ldq2, +	real *w, integer *perm, integer *givptr, integer *givcol, real *+	givnum, integer *indxp, integer *indx, integer *info);+ +/* Subroutine */ int slaed9_(integer *k, integer *kstart, integer *kstop, +	integer *n, real *d__, real *q, integer *ldq, real *rho, real *dlamda,+	 real *w, real *s, integer *lds, integer *info);+ +/* Subroutine */ int slaeda_(integer *n, integer *tlvls, integer *curlvl, +	integer *curpbm, integer *prmptr, integer *perm, integer *givptr, +	integer *givcol, real *givnum, real *q, integer *qptr, real *z__, +	real *ztemp, integer *info);+ +/* Subroutine */ int slaein_(logical *rightv, logical *noinit, integer *n, +	real *h__, integer *ldh, real *wr, real *wi, real *vr, real *vi, real +	*b, integer *ldb, real *work, real *eps3, real *smlnum, real *bignum, +	integer *info);+ +/* Subroutine */ int slaev2_(real *a, real *b, real *c__, real *rt1, real *+	rt2, real *cs1, real *sn1);+ +/* Subroutine */ int slaexc_(logical *wantq, integer *n, real *t, integer *+	ldt, real *q, integer *ldq, integer *j1, integer *n1, integer *n2, +	real *work, integer *info);+ +/* Subroutine */ int slag2_(real *a, integer *lda, real *b, integer *ldb, +	real *safmin, real *scale1, real *scale2, real *wr1, real *wr2, real *+	wi);+ +/* Subroutine */ int slags2_(logical *upper, real *a1, real *a2, real *a3, +	real *b1, real *b2, real *b3, real *csu, real *snu, real *csv, real *+	snv, real *csq, real *snq);+ +/* Subroutine */ int slagtf_(integer *n, real *a, real *lambda, real *b, real +	*c__, real *tol, real *d__, integer *in, integer *info);+ +/* Subroutine */ int slagtm_(char *trans, integer *n, integer *nrhs, real *+	alpha, real *dl, real *d__, real *du, real *x, integer *ldx, real *+	beta, real *b, integer *ldb);+ +/* Subroutine */ int slagts_(integer *job, integer *n, real *a, real *b, real +	*c__, real *d__, integer *in, real *y, real *tol, integer *info);+ +/* Subroutine */ int slagv2_(real *a, integer *lda, real *b, integer *ldb, +	real *alphar, real *alphai, real *beta, real *csl, real *snl, real *+	csr, real *snr);+ +/* Subroutine */ int slahqr_(logical *wantt, logical *wantz, integer *n, +	integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real *+	wi, integer *iloz, integer *ihiz, real *z__, integer *ldz, integer *+	info);+ +/* Subroutine */ int slahrd_(integer *n, integer *k, integer *nb, real *a, +	integer *lda, real *tau, real *t, integer *ldt, real *y, integer *ldy);+ +/* Subroutine */ int slaic1_(integer *job, integer *j, real *x, real *sest, +	real *w, real *gamma, real *sestpr, real *s, real *c__);+ +/* Subroutine */ int slaln2_(logical *ltrans, integer *na, integer *nw, real *+	smin, real *ca, real *a, integer *lda, real *d1, real *d2, real *b, +	integer *ldb, real *wr, real *wi, real *x, integer *ldx, real *scale, +	real *xnorm, integer *info);+ +/* Subroutine */ int slals0_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, integer *nrhs, real *b, integer *ldb, real *bx, +	integer *ldbx, integer *perm, integer *givptr, integer *givcol, +	integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real *+	difl, real *difr, real *z__, integer *k, real *c__, real *s, real *+	work, integer *info);+ +/* Subroutine */ int slalsa_(integer *icompq, integer *smlsiz, integer *n, +	integer *nrhs, real *b, integer *ldb, real *bx, integer *ldbx, real *+	u, integer *ldu, real *vt, integer *k, real *difl, real *difr, real *+	z__, real *poles, integer *givptr, integer *givcol, integer *ldgcol, +	integer *perm, real *givnum, real *c__, real *s, real *work, integer *+	iwork, integer *info);+ +/* Subroutine */ int slalsd_(char *uplo, integer *smlsiz, integer *n, integer +	*nrhs, real *d__, real *e, real *b, integer *ldb, real *rcond, +	integer *rank, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int slamc1_(integer *beta, integer *t, logical *rnd, logical +	*ieee1);+ +/* Subroutine */ int slamc2_(integer *beta, integer *t, logical *rnd, real *+	eps, integer *emin, real *rmin, integer *emax, real *rmax);+ +/* Subroutine */ int slamc4_(integer *emin, real *start, integer *base);+ +/* Subroutine */ int slamc5_(integer *beta, integer *p, integer *emin, +	logical *ieee, integer *emax, real *rmax);+ +/* Subroutine */ int slamrg_(integer *n1, integer *n2, real *a, integer *+	strd1, integer *strd2, integer *index);+ +/* Subroutine */ int slanv2_(real *a, real *b, real *c__, real *d__, real *+	rt1r, real *rt1i, real *rt2r, real *rt2i, real *cs, real *sn);+ +/* Subroutine */ int slapll_(integer *n, real *x, integer *incx, real *y, +	integer *incy, real *ssmin);+ +/* Subroutine */ int slapmt_(logical *forwrd, integer *m, integer *n, real *x,+	 integer *ldx, integer *k);+ +/* Subroutine */ int slaqgb_(integer *m, integer *n, integer *kl, integer *ku,+	 real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *+	colcnd, real *amax, char *equed);+ +/* Subroutine */ int slaqge_(integer *m, integer *n, real *a, integer *lda, +	real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char *+	equed);+ +/* Subroutine */ int slaqp2_(integer *m, integer *n, integer *offset, real *a,+	 integer *lda, integer *jpvt, real *tau, real *vn1, real *vn2, real *+	work);+ +/* Subroutine */ int slaqps_(integer *m, integer *n, integer *offset, integer +	*nb, integer *kb, real *a, integer *lda, integer *jpvt, real *tau, +	real *vn1, real *vn2, real *auxv, real *f, integer *ldf);+ +/* Subroutine */ int slaqsb_(char *uplo, integer *n, integer *kd, real *ab, +	integer *ldab, real *s, real *scond, real *amax, char *equed);+ +/* Subroutine */ int slaqsp_(char *uplo, integer *n, real *ap, real *s, real *+	scond, real *amax, char *equed);+ +/* Subroutine */ int slaqsy_(char *uplo, integer *n, real *a, integer *lda, +	real *s, real *scond, real *amax, char *equed);+ +/* Subroutine */ int slaqtr_(logical *ltran, logical *lreal, integer *n, real +	*t, integer *ldt, real *b, real *w, real *scale, real *x, real *work, +	integer *info);+ +/* Subroutine */ int slar1v_(integer *n, integer *b1, integer *bn, real *+	sigma, real *d__, real *l, real *ld, real *lld, real *gersch, real *+	z__, real *ztz, real *mingma, integer *r__, integer *isuppz, real *+	work);+ +/* Subroutine */ int slar2v_(integer *n, real *x, real *y, real *z__, integer +	*incx, real *c__, real *s, integer *incc);+ +/* Subroutine */ int slarf_(char *side, integer *m, integer *n, real *v, +	integer *incv, real *tau, real *c__, integer *ldc, real *work);+ +/* Subroutine */ int slarfb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, real *v, integer *ldv, +	real *t, integer *ldt, real *c__, integer *ldc, real *work, integer *+	ldwork);+ +/* Subroutine */ int slarfg_(integer *n, real *alpha, real *x, integer *incx, +	real *tau);+ +/* Subroutine */ int slarft_(char *direct, char *storev, integer *n, integer *+	k, real *v, integer *ldv, real *tau, real *t, integer *ldt);+ +/* Subroutine */ int slarfx_(char *side, integer *m, integer *n, real *v, +	real *tau, real *c__, integer *ldc, real *work);+ +/* Subroutine */ int slargv_(integer *n, real *x, integer *incx, real *y, +	integer *incy, real *c__, integer *incc);+ +/* Subroutine */ int slarnv_(integer *idist, integer *iseed, integer *n, real +	*x);+ +/* Subroutine */ int slarrb_(integer *n, real *d__, real *l, real *ld, real *+	lld, integer *ifirst, integer *ilast, real *sigma, real *reltol, real +	*w, real *wgap, real *werr, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int slarre_(integer *n, real *d__, real *e, real *tol, +	integer *nsplit, integer *isplit, integer *m, real *w, real *woff, +	real *gersch, real *work, integer *info);+ +/* Subroutine */ int slarrf_(integer *n, real *d__, real *l, real *ld, real *+	lld, integer *ifirst, integer *ilast, real *w, real *dplus, real *+	lplus, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int slarrv_(integer *n, real *d__, real *l, integer *isplit, +	integer *m, real *w, integer *iblock, real *gersch, real *tol, real *+	z__, integer *ldz, integer *isuppz, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int slartg_(real *f, real *g, real *cs, real *sn, real *r__);+ +/* Subroutine */ int slartv_(integer *n, real *x, integer *incx, real *y, +	integer *incy, real *c__, real *s, integer *incc);+ +/* Subroutine */ int slaruv_(integer *iseed, integer *n, real *x);+ +/* Subroutine */ int slarz_(char *side, integer *m, integer *n, integer *l, +	real *v, integer *incv, real *tau, real *c__, integer *ldc, real *+	work);+ +/* Subroutine */ int slarzb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, integer *l, real *v, +	integer *ldv, real *t, integer *ldt, real *c__, integer *ldc, real *+	work, integer *ldwork);+ +/* Subroutine */ int slarzt_(char *direct, char *storev, integer *n, integer *+	k, real *v, integer *ldv, real *tau, real *t, integer *ldt);+ +/* Subroutine */ int slas2_(real *f, real *g, real *h__, real *ssmin, real *+	ssmax);+ +/* Subroutine */ int slascl_(char *type__, integer *kl, integer *ku, real *+	cfrom, real *cto, integer *m, integer *n, real *a, integer *lda, +	integer *info);+ +/* Subroutine */ int slasd0_(integer *n, integer *sqre, real *d__, real *e, +	real *u, integer *ldu, real *vt, integer *ldvt, integer *smlsiz, +	integer *iwork, real *work, integer *info);+ +/* Subroutine */ int slasd1_(integer *nl, integer *nr, integer *sqre, real *+	d__, real *alpha, real *beta, real *u, integer *ldu, real *vt, +	integer *ldvt, integer *idxq, integer *iwork, real *work, integer *+	info);+ +/* Subroutine */ int slasd2_(integer *nl, integer *nr, integer *sqre, integer +	*k, real *d__, real *z__, real *alpha, real *beta, real *u, integer *+	ldu, real *vt, integer *ldvt, real *dsigma, real *u2, integer *ldu2, +	real *vt2, integer *ldvt2, integer *idxp, integer *idx, integer *idxc,+	 integer *idxq, integer *coltyp, integer *info);+ +/* Subroutine */ int slasd3_(integer *nl, integer *nr, integer *sqre, integer +	*k, real *d__, real *q, integer *ldq, real *dsigma, real *u, integer *+	ldu, real *u2, integer *ldu2, real *vt, integer *ldvt, real *vt2, +	integer *ldvt2, integer *idxc, integer *ctot, real *z__, integer *+	info);+ +/* Subroutine */ int slasd4_(integer *n, integer *i__, real *d__, real *z__, +	real *delta, real *rho, real *sigma, real *work, integer *info);+ +/* Subroutine */ int slasd5_(integer *i__, real *d__, real *z__, real *delta, +	real *rho, real *dsigma, real *work);+ +/* Subroutine */ int slasd6_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, real *d__, real *vf, real *vl, real *alpha, real *beta,+	 integer *idxq, integer *perm, integer *givptr, integer *givcol, +	integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real *+	difl, real *difr, real *z__, integer *k, real *c__, real *s, real *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int slasd7_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, integer *k, real *d__, real *z__, real *zw, real *vf, +	real *vfw, real *vl, real *vlw, real *alpha, real *beta, real *dsigma,+	 integer *idx, integer *idxp, integer *idxq, integer *perm, integer *+	givptr, integer *givcol, integer *ldgcol, real *givnum, integer *+	ldgnum, real *c__, real *s, integer *info);+ +/* Subroutine */ int slasd8_(integer *icompq, integer *k, real *d__, real *+	z__, real *vf, real *vl, real *difl, real *difr, integer *lddifr, +	real *dsigma, real *work, integer *info);+ +/* Subroutine */ int slasd9_(integer *icompq, integer *ldu, integer *k, real *+	d__, real *z__, real *vf, real *vl, real *difl, real *difr, real *+	dsigma, real *work, integer *info);+ +/* Subroutine */ int slasda_(integer *icompq, integer *smlsiz, integer *n, +	integer *sqre, real *d__, real *e, real *u, integer *ldu, real *vt, +	integer *k, real *difl, real *difr, real *z__, real *poles, integer *+	givptr, integer *givcol, integer *ldgcol, integer *perm, real *givnum,+	 real *c__, real *s, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int slasdq_(char *uplo, integer *sqre, integer *n, integer *+	ncvt, integer *nru, integer *ncc, real *d__, real *e, real *vt, +	integer *ldvt, real *u, integer *ldu, real *c__, integer *ldc, real *+	work, integer *info);+ +/* Subroutine */ int slasdt_(integer *n, integer *lvl, integer *nd, integer *+	inode, integer *ndiml, integer *ndimr, integer *msub);+ +/* Subroutine */ int slaset_(char *uplo, integer *m, integer *n, real *alpha, +	real *beta, real *a, integer *lda);+ +/* Subroutine */ int slasq1_(integer *n, real *d__, real *e, real *work, +	integer *info);+ +/* Subroutine */ int slasq2_(integer *n, real *z__, integer *info);+ +/* Subroutine */ int slasq3_(integer *i0, integer *n0, real *z__, integer *pp,+	 real *dmin__, real *sigma, real *desig, real *qmax, integer *nfail, +	integer *iter, integer *ndiv, logical *ieee);+ +/* Subroutine */ int slasq4_(integer *i0, integer *n0, real *z__, integer *pp,+	 integer *n0in, real *dmin__, real *dmin1, real *dmin2, real *dn, +	real *dn1, real *dn2, real *tau, integer *ttype);+ +/* Subroutine */ int slasq5_(integer *i0, integer *n0, real *z__, integer *pp,+	 real *tau, real *dmin__, real *dmin1, real *dmin2, real *dn, real *+	dnm1, real *dnm2, logical *ieee);+ +/* Subroutine */ int slasq6_(integer *i0, integer *n0, real *z__, integer *pp,+	 real *dmin__, real *dmin1, real *dmin2, real *dn, real *dnm1, real *+	dnm2);+ +/* Subroutine */ int slasr_(char *side, char *pivot, char *direct, integer *m,+	 integer *n, real *c__, real *s, real *a, integer *lda);+ +/* Subroutine */ int slasrt_(char *id, integer *n, real *d__, integer *info);+ +/* Subroutine */ int slassq_(integer *n, real *x, integer *incx, real *scale, +	real *sumsq);+ +/* Subroutine */ int slasv2_(real *f, real *g, real *h__, real *ssmin, real *+	ssmax, real *snr, real *csr, real *snl, real *csl);+ +/* Subroutine */ int slaswp_(integer *n, real *a, integer *lda, integer *k1, +	integer *k2, integer *ipiv, integer *incx);+ +/* Subroutine */ int slasy2_(logical *ltranl, logical *ltranr, integer *isgn, +	integer *n1, integer *n2, real *tl, integer *ldtl, real *tr, integer *+	ldtr, real *b, integer *ldb, real *scale, real *x, integer *ldx, real +	*xnorm, integer *info);+ +/* Subroutine */ int slasyf_(char *uplo, integer *n, integer *nb, integer *kb,+	 real *a, integer *lda, integer *ipiv, real *w, integer *ldw, integer +	*info);+ +/* Subroutine */ int slatbs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, integer *kd, real *ab, integer *ldab, real *x, +	real *scale, real *cnorm, integer *info);+ +/* Subroutine */ int slatdf_(integer *ijob, integer *n, real *z__, integer *+	ldz, real *rhs, real *rdsum, real *rdscal, integer *ipiv, integer *+	jpiv);+ +/* Subroutine */ int slatps_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, real *ap, real *x, real *scale, real *cnorm, +	integer *info);+ +/* Subroutine */ int slatrd_(char *uplo, integer *n, integer *nb, real *a, +	integer *lda, real *e, real *tau, real *w, integer *ldw);+ +/* Subroutine */ int slatrs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, real *a, integer *lda, real *x, real *scale, real +	*cnorm, integer *info);+ +/* Subroutine */ int slatrz_(integer *m, integer *n, integer *l, real *a, +	integer *lda, real *tau, real *work);+ +/* Subroutine */ int slatzm_(char *side, integer *m, integer *n, real *v, +	integer *incv, real *tau, real *c1, real *c2, integer *ldc, real *+	work);+ +/* Subroutine */ int slauu2_(char *uplo, integer *n, real *a, integer *lda, +	integer *info);+ +/* Subroutine */ int slauum_(char *uplo, integer *n, real *a, integer *lda, +	integer *info);+ +/* Subroutine */ int sopgtr_(char *uplo, integer *n, real *ap, real *tau, +	real *q, integer *ldq, real *work, integer *info);+ +/* Subroutine */ int sopmtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, real *ap, real *tau, real *c__, integer *ldc, real *work, +	integer *info);+ +/* Subroutine */ int sorg2l_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *info);+ +/* Subroutine */ int sorg2r_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *info);+ +/* Subroutine */ int sorgbr_(char *vect, integer *m, integer *n, integer *k, +	real *a, integer *lda, real *tau, real *work, integer *lwork, integer +	*info);+ +/* Subroutine */ int sorghr_(integer *n, integer *ilo, integer *ihi, real *a, +	integer *lda, real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sorgl2_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *info);+ +/* Subroutine */ int sorglq_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sorgql_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sorgqr_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sorgr2_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *info);+ +/* Subroutine */ int sorgrq_(integer *m, integer *n, integer *k, real *a, +	integer *lda, real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sorgtr_(char *uplo, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sorm2l_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *info);+ +/* Subroutine */ int sorm2r_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *info);+ +/* Subroutine */ int sormbr_(char *vect, char *side, char *trans, integer *m, +	integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, +	integer *ldc, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sormhr_(char *side, char *trans, integer *m, integer *n, +	integer *ilo, integer *ihi, real *a, integer *lda, real *tau, real *+	c__, integer *ldc, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sorml2_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *info);+ +/* Subroutine */ int sormlq_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sormql_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sormqr_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sormr2_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *info);+ +/* Subroutine */ int sormr3_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, real *a, integer *lda, real *tau, real *c__, +	integer *ldc, real *work, integer *info);+ +/* Subroutine */ int sormrq_(char *side, char *trans, integer *m, integer *n, +	integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sormrz_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, real *a, integer *lda, real *tau, real *c__, +	integer *ldc, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int sormtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, real *a, integer *lda, real *tau, real *c__, integer *ldc,+	 real *work, integer *lwork, integer *info);+ +/* Subroutine */ int spbcon_(char *uplo, integer *n, integer *kd, real *ab, +	integer *ldab, real *anorm, real *rcond, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int spbequ_(char *uplo, integer *n, integer *kd, real *ab, +	integer *ldab, real *s, real *scond, real *amax, integer *info);+ +/* Subroutine */ int spbrfs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, real *b, +	integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int spbstf_(char *uplo, integer *n, integer *kd, real *ab, +	integer *ldab, integer *info);+ +/* Subroutine */ int spbsv_(char *uplo, integer *n, integer *kd, integer *+	nrhs, real *ab, integer *ldab, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int spbsvx_(char *fact, char *uplo, integer *n, integer *kd, +	integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, +	char *equed, real *s, real *b, integer *ldb, real *x, integer *ldx, +	real *rcond, real *ferr, real *berr, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int spbtf2_(char *uplo, integer *n, integer *kd, real *ab, +	integer *ldab, integer *info);+ +/* Subroutine */ int spbtrf_(char *uplo, integer *n, integer *kd, real *ab, +	integer *ldab, integer *info);+ +/* Subroutine */ int spbtrs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, real *ab, integer *ldab, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int spocon_(char *uplo, integer *n, real *a, integer *lda, +	real *anorm, real *rcond, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int spoequ_(integer *n, real *a, integer *lda, real *s, real +	*scond, real *amax, integer *info);+ +/* Subroutine */ int sporfs_(char *uplo, integer *n, integer *nrhs, real *a, +	integer *lda, real *af, integer *ldaf, real *b, integer *ldb, real *x,+	 integer *ldx, real *ferr, real *berr, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int sposv_(char *uplo, integer *n, integer *nrhs, real *a, +	integer *lda, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sposvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, real *a, integer *lda, real *af, integer *ldaf, char *equed, +	real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, +	real *ferr, real *berr, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int spotf2_(char *uplo, integer *n, real *a, integer *lda, +	integer *info);+ +/* Subroutine */ int spotrf_(char *uplo, integer *n, real *a, integer *lda, +	integer *info);+ +/* Subroutine */ int spotri_(char *uplo, integer *n, real *a, integer *lda, +	integer *info);+ +/* Subroutine */ int spotrs_(char *uplo, integer *n, integer *nrhs, real *a, +	integer *lda, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sppcon_(char *uplo, integer *n, real *ap, real *anorm, +	real *rcond, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sppequ_(char *uplo, integer *n, real *ap, real *s, real *+	scond, real *amax, integer *info);+ +/* Subroutine */ int spprfs_(char *uplo, integer *n, integer *nrhs, real *ap, +	real *afp, real *b, integer *ldb, real *x, integer *ldx, real *ferr, +	real *berr, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sppsv_(char *uplo, integer *n, integer *nrhs, real *ap, +	real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sppsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, real *ap, real *afp, char *equed, real *s, real *b, integer *+	ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real +	*work, integer *iwork, integer *info);+ +/* Subroutine */ int spptrf_(char *uplo, integer *n, real *ap, integer *info);+ +/* Subroutine */ int spptri_(char *uplo, integer *n, real *ap, integer *info);+ +/* Subroutine */ int spptrs_(char *uplo, integer *n, integer *nrhs, real *ap, +	real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sptcon_(integer *n, real *d__, real *e, real *anorm, +	real *rcond, real *work, integer *info);+ +/* Subroutine */ int spteqr_(char *compz, integer *n, real *d__, real *e, +	real *z__, integer *ldz, real *work, integer *info);+ +/* Subroutine */ int sptrfs_(integer *n, integer *nrhs, real *d__, real *e, +	real *df, real *ef, real *b, integer *ldb, real *x, integer *ldx, +	real *ferr, real *berr, real *work, integer *info);+ +/* Subroutine */ int sptsv_(integer *n, integer *nrhs, real *d__, real *e, +	real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sptsvx_(char *fact, integer *n, integer *nrhs, real *d__,+	 real *e, real *df, real *ef, real *b, integer *ldb, real *x, integer +	*ldx, real *rcond, real *ferr, real *berr, real *work, integer *info);+ +/* Subroutine */ int spttrf_(integer *n, real *d__, real *e, integer *info);+ +/* Subroutine */ int spttrs_(integer *n, integer *nrhs, real *d__, real *e, +	real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sptts2_(integer *n, integer *nrhs, real *d__, real *e, +	real *b, integer *ldb);+ +/* Subroutine */ int srscl_(integer *n, real *sa, real *sx, integer *incx);+ +/* Subroutine */ int ssbev_(char *jobz, char *uplo, integer *n, integer *kd, +	real *ab, integer *ldab, real *w, real *z__, integer *ldz, real *work,+	 integer *info);+ +/* Subroutine */ int ssbevd_(char *jobz, char *uplo, integer *n, integer *kd, +	real *ab, integer *ldab, real *w, real *z__, integer *ldz, real *work,+	 integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int ssbevx_(char *jobz, char *range, char *uplo, integer *n, +	integer *kd, real *ab, integer *ldab, real *q, integer *ldq, real *vl,+	 real *vu, integer *il, integer *iu, real *abstol, integer *m, real *+	w, real *z__, integer *ldz, real *work, integer *iwork, integer *+	ifail, integer *info);+ +/* Subroutine */ int ssbgst_(char *vect, char *uplo, integer *n, integer *ka, +	integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real *+	x, integer *ldx, real *work, integer *info);+ +/* Subroutine */ int ssbgv_(char *jobz, char *uplo, integer *n, integer *ka, +	integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real *+	w, real *z__, integer *ldz, real *work, integer *info);+ +/* Subroutine */ int ssbgvd_(char *jobz, char *uplo, integer *n, integer *ka, +	integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real *+	w, real *z__, integer *ldz, real *work, integer *lwork, integer *+	iwork, integer *liwork, integer *info);+ +/* Subroutine */ int ssbgvx_(char *jobz, char *range, char *uplo, integer *n, +	integer *ka, integer *kb, real *ab, integer *ldab, real *bb, integer *+	ldbb, real *q, integer *ldq, real *vl, real *vu, integer *il, integer +	*iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, real +	*work, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int ssbtrd_(char *vect, char *uplo, integer *n, integer *kd, +	real *ab, integer *ldab, real *d__, real *e, real *q, integer *ldq, +	real *work, integer *info);+ +/* Subroutine */ int sspcon_(char *uplo, integer *n, real *ap, integer *ipiv, +	real *anorm, real *rcond, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sspev_(char *jobz, char *uplo, integer *n, real *ap, +	real *w, real *z__, integer *ldz, real *work, integer *info);+ +/* Subroutine */ int sspevd_(char *jobz, char *uplo, integer *n, real *ap, +	real *w, real *z__, integer *ldz, real *work, integer *lwork, integer +	*iwork, integer *liwork, integer *info);+ +/* Subroutine */ int sspevx_(char *jobz, char *range, char *uplo, integer *n, +	real *ap, real *vl, real *vu, integer *il, integer *iu, real *abstol, +	integer *m, real *w, real *z__, integer *ldz, real *work, integer *+	iwork, integer *ifail, integer *info);+ +/* Subroutine */ int sspgst_(integer *itype, char *uplo, integer *n, real *ap,+	 real *bp, integer *info);+ +/* Subroutine */ int sspgv_(integer *itype, char *jobz, char *uplo, integer *+	n, real *ap, real *bp, real *w, real *z__, integer *ldz, real *work, +	integer *info);+ +/* Subroutine */ int sspgvd_(integer *itype, char *jobz, char *uplo, integer *+	n, real *ap, real *bp, real *w, real *z__, integer *ldz, real *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int sspgvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, real *ap, real *bp, real *vl, real *vu, integer *il,+	 integer *iu, real *abstol, integer *m, real *w, real *z__, integer *+	ldz, real *work, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int ssprfs_(char *uplo, integer *n, integer *nrhs, real *ap, +	real *afp, integer *ipiv, real *b, integer *ldb, real *x, integer *+	ldx, real *ferr, real *berr, real *work, integer *iwork, integer *+	info);+ +/* Subroutine */ int sspsv_(char *uplo, integer *n, integer *nrhs, real *ap, +	integer *ipiv, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sspsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, real *ap, real *afp, integer *ipiv, real *b, integer *ldb, real +	*x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, +	integer *iwork, integer *info);+ +/* Subroutine */ int ssptrd_(char *uplo, integer *n, real *ap, real *d__, +	real *e, real *tau, integer *info);+ +/* Subroutine */ int ssptrf_(char *uplo, integer *n, real *ap, integer *ipiv, +	integer *info);+ +/* Subroutine */ int ssptri_(char *uplo, integer *n, real *ap, integer *ipiv, +	real *work, integer *info);+ +/* Subroutine */ int ssptrs_(char *uplo, integer *n, integer *nrhs, real *ap, +	integer *ipiv, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int sstebz_(char *range, char *order, integer *n, real *vl, +	real *vu, integer *il, integer *iu, real *abstol, real *d__, real *e, +	integer *m, integer *nsplit, real *w, integer *iblock, integer *+	isplit, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int sstedc_(char *compz, integer *n, real *d__, real *e, +	real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int sstegr_(char *jobz, char *range, integer *n, real *d__, +	real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, +	integer *m, real *w, real *z__, integer *ldz, integer *isuppz, real *+	work, integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int sstein_(integer *n, real *d__, real *e, integer *m, real +	*w, integer *iblock, integer *isplit, real *z__, integer *ldz, real *+	work, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int ssteqr_(char *compz, integer *n, real *d__, real *e, +	real *z__, integer *ldz, real *work, integer *info);+ +/* Subroutine */ int ssterf_(integer *n, real *d__, real *e, integer *info);+ +/* Subroutine */ int sstev_(char *jobz, integer *n, real *d__, real *e, real *+	z__, integer *ldz, real *work, integer *info);+ +/* Subroutine */ int sstevd_(char *jobz, integer *n, real *d__, real *e, real +	*z__, integer *ldz, real *work, integer *lwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int sstevr_(char *jobz, char *range, integer *n, real *d__, +	real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, +	integer *m, real *w, real *z__, integer *ldz, integer *isuppz, real *+	work, integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int sstevx_(char *jobz, char *range, integer *n, real *d__, +	real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, +	integer *m, real *w, real *z__, integer *ldz, real *work, integer *+	iwork, integer *ifail, integer *info);+ +/* Subroutine */ int ssycon_(char *uplo, integer *n, real *a, integer *lda, +	integer *ipiv, real *anorm, real *rcond, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int ssyev_(char *jobz, char *uplo, integer *n, real *a, +	integer *lda, real *w, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int ssyevd_(char *jobz, char *uplo, integer *n, real *a, +	integer *lda, real *w, real *work, integer *lwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int ssyevr_(char *jobz, char *range, char *uplo, integer *n, +	real *a, integer *lda, real *vl, real *vu, integer *il, integer *iu, +	real *abstol, integer *m, real *w, real *z__, integer *ldz, integer *+	isuppz, real *work, integer *lwork, integer *iwork, integer *liwork, +	integer *info);+ +/* Subroutine */ int ssyevx_(char *jobz, char *range, char *uplo, integer *n, +	real *a, integer *lda, real *vl, real *vu, integer *il, integer *iu, +	real *abstol, integer *m, real *w, real *z__, integer *ldz, real *+	work, integer *lwork, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int ssygs2_(integer *itype, char *uplo, integer *n, real *a, +	integer *lda, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int ssygst_(integer *itype, char *uplo, integer *n, real *a, +	integer *lda, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int ssygv_(integer *itype, char *jobz, char *uplo, integer *+	n, real *a, integer *lda, real *b, integer *ldb, real *w, real *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int ssygvd_(integer *itype, char *jobz, char *uplo, integer *+	n, real *a, integer *lda, real *b, integer *ldb, real *w, real *work, +	integer *lwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int ssygvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, real *a, integer *lda, real *b, integer *ldb, real *+	vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, +	real *w, real *z__, integer *ldz, real *work, integer *lwork, integer +	*iwork, integer *ifail, integer *info);+ +/* Subroutine */ int ssyrfs_(char *uplo, integer *n, integer *nrhs, real *a, +	integer *lda, real *af, integer *ldaf, integer *ipiv, real *b, +	integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *+	work, integer *iwork, integer *info);+ +/* Subroutine */ int ssysv_(char *uplo, integer *n, integer *nrhs, real *a, +	integer *lda, integer *ipiv, real *b, integer *ldb, real *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int ssysvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, +	real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr,+	 real *berr, real *work, integer *lwork, integer *iwork, integer *+	info);+ +/* Subroutine */ int ssytd2_(char *uplo, integer *n, real *a, integer *lda, +	real *d__, real *e, real *tau, integer *info);+ +/* Subroutine */ int ssytf2_(char *uplo, integer *n, real *a, integer *lda, +	integer *ipiv, integer *info);+ +/* Subroutine */ int ssytrd_(char *uplo, integer *n, real *a, integer *lda, +	real *d__, real *e, real *tau, real *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int ssytrf_(char *uplo, integer *n, real *a, integer *lda, +	integer *ipiv, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int ssytri_(char *uplo, integer *n, real *a, integer *lda, +	integer *ipiv, real *work, integer *info);+ +/* Subroutine */ int ssytrs_(char *uplo, integer *n, integer *nrhs, real *a, +	integer *lda, integer *ipiv, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int stbcon_(char *norm, char *uplo, char *diag, integer *n, +	integer *kd, real *ab, integer *ldab, real *rcond, real *work, +	integer *iwork, integer *info);+ +/* Subroutine */ int stbrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, real *ab, integer *ldab, real *b, integer +	*ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, +	integer *iwork, integer *info);+ +/* Subroutine */ int stbtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, real *ab, integer *ldab, real *b, integer +	*ldb, integer *info);+ +/* Subroutine */ int stgevc_(char *side, char *howmny, logical *select, +	integer *n, real *a, integer *lda, real *b, integer *ldb, real *vl, +	integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, real +	*work, integer *info);+ +/* Subroutine */ int stgex2_(logical *wantq, logical *wantz, integer *n, real +	*a, integer *lda, real *b, integer *ldb, real *q, integer *ldq, real *+	z__, integer *ldz, integer *j1, integer *n1, integer *n2, real *work, +	integer *lwork, integer *info);+ +/* Subroutine */ int stgexc_(logical *wantq, logical *wantz, integer *n, real +	*a, integer *lda, real *b, integer *ldb, real *q, integer *ldq, real *+	z__, integer *ldz, integer *ifst, integer *ilst, real *work, integer *+	lwork, integer *info);+ +/* Subroutine */ int stgsen_(integer *ijob, logical *wantq, logical *wantz, +	logical *select, integer *n, real *a, integer *lda, real *b, integer *+	ldb, real *alphar, real *alphai, real *beta, real *q, integer *ldq, +	real *z__, integer *ldz, integer *m, real *pl, real *pr, real *dif, +	real *work, integer *lwork, integer *iwork, integer *liwork, integer *+	info);+ +/* Subroutine */ int stgsja_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, integer *k, integer *l, real *a, integer *lda,+	 real *b, integer *ldb, real *tola, real *tolb, real *alpha, real *+	beta, real *u, integer *ldu, real *v, integer *ldv, real *q, integer *+	ldq, real *work, integer *ncycle, integer *info);+ +/* Subroutine */ int stgsna_(char *job, char *howmny, logical *select, +	integer *n, real *a, integer *lda, real *b, integer *ldb, real *vl, +	integer *ldvl, real *vr, integer *ldvr, real *s, real *dif, integer *+	mm, integer *m, real *work, integer *lwork, integer *iwork, integer *+	info);+ +/* Subroutine */ int stgsy2_(char *trans, integer *ijob, integer *m, integer *+	n, real *a, integer *lda, real *b, integer *ldb, real *c__, integer *+	ldc, real *d__, integer *ldd, real *e, integer *lde, real *f, integer +	*ldf, real *scale, real *rdsum, real *rdscal, integer *iwork, integer +	*pq, integer *info);+ +/* Subroutine */ int stgsyl_(char *trans, integer *ijob, integer *m, integer *+	n, real *a, integer *lda, real *b, integer *ldb, real *c__, integer *+	ldc, real *d__, integer *ldd, real *e, integer *lde, real *f, integer +	*ldf, real *scale, real *dif, real *work, integer *lwork, integer *+	iwork, integer *info);+ +/* Subroutine */ int stpcon_(char *norm, char *uplo, char *diag, integer *n, +	real *ap, real *rcond, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int stprfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, real *ap, real *b, integer *ldb, real *x, integer *ldx,+	 real *ferr, real *berr, real *work, integer *iwork, integer *info);+ +/* Subroutine */ int stptri_(char *uplo, char *diag, integer *n, real *ap, +	integer *info);+ +/* Subroutine */ int stptrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, real *ap, real *b, integer *ldb, integer *info);+ +/* Subroutine */ int strcon_(char *norm, char *uplo, char *diag, integer *n, +	real *a, integer *lda, real *rcond, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int strevc_(char *side, char *howmny, logical *select, +	integer *n, real *t, integer *ldt, real *vl, integer *ldvl, real *vr, +	integer *ldvr, integer *mm, integer *m, real *work, integer *info);+ +/* Subroutine */ int strexc_(char *compq, integer *n, real *t, integer *ldt, +	real *q, integer *ldq, integer *ifst, integer *ilst, real *work, +	integer *info);+ +/* Subroutine */ int strrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, real *a, integer *lda, real *b, integer *ldb, real *x, +	integer *ldx, real *ferr, real *berr, real *work, integer *iwork, +	integer *info);+ +/* Subroutine */ int strsen_(char *job, char *compq, logical *select, integer +	*n, real *t, integer *ldt, real *q, integer *ldq, real *wr, real *wi, +	integer *m, real *s, real *sep, real *work, integer *lwork, integer *+	iwork, integer *liwork, integer *info);+ +/* Subroutine */ int strsna_(char *job, char *howmny, logical *select, +	integer *n, real *t, integer *ldt, real *vl, integer *ldvl, real *vr, +	integer *ldvr, real *s, real *sep, integer *mm, integer *m, real *+	work, integer *ldwork, integer *iwork, integer *info);+ +/* Subroutine */ int strsyl_(char *trana, char *tranb, integer *isgn, integer +	*m, integer *n, real *a, integer *lda, real *b, integer *ldb, real *+	c__, integer *ldc, real *scale, integer *info);+ +/* Subroutine */ int strti2_(char *uplo, char *diag, integer *n, real *a, +	integer *lda, integer *info);+ +/* Subroutine */ int strtri_(char *uplo, char *diag, integer *n, real *a, +	integer *lda, integer *info);+ +/* Subroutine */ int strtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, real *a, integer *lda, real *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int stzrqf_(integer *m, integer *n, real *a, integer *lda, +	real *tau, integer *info);+ +/* Subroutine */ int stzrzf_(integer *m, integer *n, real *a, integer *lda, +	real *tau, real *work, integer *lwork, integer *info);+ +/* Subroutine */ int xerbla_(char *srname, integer *info);+ +/* Subroutine */ int zbdsqr_(char *uplo, integer *n, integer *ncvt, integer *+	nru, integer *ncc, doublereal *d__, doublereal *e, doublecomplex *vt, +	integer *ldvt, doublecomplex *u, integer *ldu, doublecomplex *c__, +	integer *ldc, doublereal *rwork, integer *info);+ +/* Subroutine */ int zdrot_(integer *n, doublecomplex *cx, integer *incx, +	doublecomplex *cy, integer *incy, doublereal *c__, doublereal *s);+ +/* Subroutine */ int zdrscl_(integer *n, doublereal *sa, doublecomplex *sx, +	integer *incx);+ +/* Subroutine */ int zgbbrd_(char *vect, integer *m, integer *n, integer *ncc,+	 integer *kl, integer *ku, doublecomplex *ab, integer *ldab, +	doublereal *d__, doublereal *e, doublecomplex *q, integer *ldq, +	doublecomplex *pt, integer *ldpt, doublecomplex *c__, integer *ldc, +	doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgbcon_(char *norm, integer *n, integer *kl, integer *ku,+	 doublecomplex *ab, integer *ldab, integer *ipiv, doublereal *anorm, +	doublereal *rcond, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zgbequ_(integer *m, integer *n, integer *kl, integer *ku,+	 doublecomplex *ab, integer *ldab, doublereal *r__, doublereal *c__, +	doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *+	info);+ +/* Subroutine */ int zgbrfs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *+	afb, integer *ldafb, integer *ipiv, doublecomplex *b, integer *ldb, +	doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgbsv_(integer *n, integer *kl, integer *ku, integer *+	nrhs, doublecomplex *ab, integer *ldab, integer *ipiv, doublecomplex *+	b, integer *ldb, integer *info);+ +/* Subroutine */ int zgbsvx_(char *fact, char *trans, integer *n, integer *kl,+	 integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, +	doublecomplex *afb, integer *ldafb, integer *ipiv, char *equed, +	doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, +	doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, +	doublereal *berr, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zgbtf2_(integer *m, integer *n, integer *kl, integer *ku,+	 doublecomplex *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int zgbtrf_(integer *m, integer *n, integer *kl, integer *ku,+	 doublecomplex *ab, integer *ldab, integer *ipiv, integer *info);+ +/* Subroutine */ int zgbtrs_(char *trans, integer *n, integer *kl, integer *+	ku, integer *nrhs, doublecomplex *ab, integer *ldab, integer *ipiv, +	doublecomplex *b, integer *ldb, integer *info);+ +/* Subroutine */ int zgebak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, doublereal *scale, integer *m, doublecomplex *v, +	integer *ldv, integer *info);+ +/* Subroutine */ int zgebal_(char *job, integer *n, doublecomplex *a, integer +	*lda, integer *ilo, integer *ihi, doublereal *scale, integer *info);+ +/* Subroutine */ int zgebd2_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublereal *d__, doublereal *e, doublecomplex *tauq, +	doublecomplex *taup, doublecomplex *work, integer *info);+ +/* Subroutine */ int zgebrd_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublereal *d__, doublereal *e, doublecomplex *tauq, +	doublecomplex *taup, doublecomplex *work, integer *lwork, integer *+	info);+ +/* Subroutine */ int zgecon_(char *norm, integer *n, doublecomplex *a, +	integer *lda, doublereal *anorm, doublereal *rcond, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgeequ_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, +	doublereal *colcnd, doublereal *amax, integer *info);+ +/* Subroutine */ int zgees_(char *jobvs, char *sort, L_fp select, integer *n, +	doublecomplex *a, integer *lda, integer *sdim, doublecomplex *w, +	doublecomplex *vs, integer *ldvs, doublecomplex *work, integer *lwork,+	 doublereal *rwork, logical *bwork, integer *info);+ +/* Subroutine */ int zgeesx_(char *jobvs, char *sort, L_fp select, char *+	sense, integer *n, doublecomplex *a, integer *lda, integer *sdim, +	doublecomplex *w, doublecomplex *vs, integer *ldvs, doublereal *+	rconde, doublereal *rcondv, doublecomplex *work, integer *lwork, +	doublereal *rwork, logical *bwork, integer *info);+ +/* Subroutine */ int zgeev_(char *jobvl, char *jobvr, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *w, doublecomplex *vl, +	integer *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, +	integer *lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgeevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *w, +	doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, +	integer *ilo, integer *ihi, doublereal *scale, doublereal *abnrm, +	doublereal *rconde, doublereal *rcondv, doublecomplex *work, integer *+	lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgegs_(char *jobvsl, char *jobvsr, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, +	integer *ldvsl, doublecomplex *vsr, integer *ldvsr, doublecomplex *+	work, integer *lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgegv_(char *jobvl, char *jobvr, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer +	*ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer +	*lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgehd2_(integer *n, integer *ilo, integer *ihi, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zgehrd_(integer *n, integer *ilo, integer *ihi, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zgelq2_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);+ +/* Subroutine */ int zgelqf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zgels_(char *trans, integer *m, integer *n, integer *+	nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *work, integer *lwork, integer *info);+ +/* Subroutine */ int zgelsx_(integer *m, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	integer *jpvt, doublereal *rcond, integer *rank, doublecomplex *work, +	doublereal *rwork, integer *info);+ +/* Subroutine */ int zgelsy_(integer *m, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	integer *jpvt, doublereal *rcond, integer *rank, doublecomplex *work, +	integer *lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgeql2_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);+ +/* Subroutine */ int zgeqlf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zgeqp3_(integer *m, integer *n, doublecomplex *a, +	integer *lda, integer *jpvt, doublecomplex *tau, doublecomplex *work, +	integer *lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgeqpf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, integer *jpvt, doublecomplex *tau, doublecomplex *work, +	doublereal *rwork, integer *info);+ +/* Subroutine */ int zgeqr2_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);+ +/* Subroutine */ int zgeqrf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zgerfs_(char *trans, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, +	integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, +	integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work,+	 doublereal *rwork, integer *info);+ +/* Subroutine */ int zgerq2_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);+ +/* Subroutine */ int zgerqf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zgesc2_(integer *n, doublecomplex *a, integer *lda, +	doublecomplex *rhs, integer *ipiv, integer *jpiv, doublereal *scale);+ +/* Subroutine */ int zgesv_(integer *n, integer *nrhs, doublecomplex *a, +	integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, integer *+	info);+ +/* Subroutine */ int zgesvx_(char *fact, char *trans, integer *n, integer *+	nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *+	ldaf, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, +	doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgetc2_(integer *n, doublecomplex *a, integer *lda, +	integer *ipiv, integer *jpiv, integer *info);+ +/* Subroutine */ int zgetf2_(integer *m, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, integer *info);+ +/* Subroutine */ int zgetrf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, integer *info);+ +/* Subroutine */ int zgetri_(integer *n, doublecomplex *a, integer *lda, +	integer *ipiv, doublecomplex *work, integer *lwork, integer *info);+ +/* Subroutine */ int zgetrs_(char *trans, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, +	integer *ldb, integer *info);+ +/* Subroutine */ int zggbak_(char *job, char *side, integer *n, integer *ilo, +	integer *ihi, doublereal *lscale, doublereal *rscale, integer *m, +	doublecomplex *v, integer *ldv, integer *info);+ +/* Subroutine */ int zggbal_(char *job, integer *n, doublecomplex *a, integer +	*lda, doublecomplex *b, integer *ldb, integer *ilo, integer *ihi, +	doublereal *lscale, doublereal *rscale, doublereal *work, integer *+	info);+ +/* Subroutine */ int zgges_(char *jobvsl, char *jobvsr, char *sort, L_fp +	delctg, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, +	integer *ldb, integer *sdim, doublecomplex *alpha, doublecomplex *+	beta, doublecomplex *vsl, integer *ldvsl, doublecomplex *vsr, integer +	*ldvsr, doublecomplex *work, integer *lwork, doublereal *rwork, +	logical *bwork, integer *info);+ +/* Subroutine */ int zggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp +	delctg, char *sense, integer *n, doublecomplex *a, integer *lda, +	doublecomplex *b, integer *ldb, integer *sdim, doublecomplex *alpha, +	doublecomplex *beta, doublecomplex *vsl, integer *ldvsl, +	doublecomplex *vsr, integer *ldvsr, doublereal *rconde, doublereal *+	rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, +	integer *iwork, integer *liwork, logical *bwork, integer *info);+ +/* Subroutine */ int zggev_(char *jobvl, char *jobvr, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer +	*ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer +	*lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zggevx_(char *balanc, char *jobvl, char *jobvr, char *+	sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, +	integer *ldb, doublecomplex *alpha, doublecomplex *beta, +	doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, +	integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, +	doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal *+	rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, +	integer *iwork, logical *bwork, integer *info);+ +/* Subroutine */ int zggglm_(integer *n, integer *m, integer *p, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *d__, doublecomplex *x, doublecomplex *y, doublecomplex +	*work, integer *lwork, integer *info);+ +/* Subroutine */ int zgghrd_(char *compq, char *compz, integer *n, integer *+	ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *b, +	integer *ldb, doublecomplex *q, integer *ldq, doublecomplex *z__, +	integer *ldz, integer *info);+ +/* Subroutine */ int zgglse_(integer *m, integer *n, integer *p, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *c__, doublecomplex *d__, doublecomplex *x, +	doublecomplex *work, integer *lwork, integer *info);+ +/* Subroutine */ int zggqrf_(integer *n, integer *m, integer *p, +	doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b,+	 integer *ldb, doublecomplex *taub, doublecomplex *work, integer *+	lwork, integer *info);+ +/* Subroutine */ int zggrqf_(integer *m, integer *p, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b,+	 integer *ldb, doublecomplex *taub, doublecomplex *work, integer *+	lwork, integer *info);+ +/* Subroutine */ int zggsvd_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *n, integer *p, integer *k, integer *l, doublecomplex *a, +	integer *lda, doublecomplex *b, integer *ldb, doublereal *alpha, +	doublereal *beta, doublecomplex *u, integer *ldu, doublecomplex *v, +	integer *ldv, doublecomplex *q, integer *ldq, doublecomplex *work, +	doublereal *rwork, integer *iwork, integer *info);+ +/* Subroutine */ int zggsvp_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, doublecomplex *a, integer *lda, doublecomplex +	*b, integer *ldb, doublereal *tola, doublereal *tolb, integer *k, +	integer *l, doublecomplex *u, integer *ldu, doublecomplex *v, integer +	*ldv, doublecomplex *q, integer *ldq, integer *iwork, doublereal *+	rwork, doublecomplex *tau, doublecomplex *work, integer *info);+ +/* Subroutine */ int zgtcon_(char *norm, integer *n, doublecomplex *dl, +	doublecomplex *d__, doublecomplex *du, doublecomplex *du2, integer *+	ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *work, +	integer *info);+ +/* Subroutine */ int zgtrfs_(char *trans, integer *n, integer *nrhs, +	doublecomplex *dl, doublecomplex *d__, doublecomplex *du, +	doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, +	doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, +	doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zgtsv_(integer *n, integer *nrhs, doublecomplex *dl, +	doublecomplex *d__, doublecomplex *du, doublecomplex *b, integer *ldb,+	 integer *info);+ +/* Subroutine */ int zgtsvx_(char *fact, char *trans, integer *n, integer *+	nrhs, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, +	doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, +	doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, +	doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, +	doublereal *berr, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zgttrf_(integer *n, doublecomplex *dl, doublecomplex *+	d__, doublecomplex *du, doublecomplex *du2, integer *ipiv, integer *+	info);+ +/* Subroutine */ int zgttrs_(char *trans, integer *n, integer *nrhs, +	doublecomplex *dl, doublecomplex *d__, doublecomplex *du, +	doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zgtts2_(integer *itrans, integer *n, integer *nrhs, +	doublecomplex *dl, doublecomplex *d__, doublecomplex *du, +	doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb);+ +/* Subroutine */ int zhbev_(char *jobz, char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, doublereal *w, doublecomplex *z__, +	integer *ldz, doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zhbevd_(char *jobz, char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, doublereal *w, doublecomplex *z__, +	integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, +	integer *lrwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int zhbevx_(char *jobz, char *range, char *uplo, integer *n, +	integer *kd, doublecomplex *ab, integer *ldab, doublecomplex *q, +	integer *ldq, doublereal *vl, doublereal *vu, integer *il, integer *+	iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__,+	 integer *ldz, doublecomplex *work, doublereal *rwork, integer *iwork,+	 integer *ifail, integer *info);+ +/* Subroutine */ int zhbgst_(char *vect, char *uplo, integer *n, integer *ka, +	integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, +	integer *ldbb, doublecomplex *x, integer *ldx, doublecomplex *work, +	doublereal *rwork, integer *info);+ +/* Subroutine */ int zhbgv_(char *jobz, char *uplo, integer *n, integer *ka, +	integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, +	integer *ldbb, doublereal *w, doublecomplex *z__, integer *ldz, +	doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zhbgvx_(char *jobz, char *range, char *uplo, integer *n, +	integer *ka, integer *kb, doublecomplex *ab, integer *ldab, +	doublecomplex *bb, integer *ldbb, doublecomplex *q, integer *ldq, +	doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *+	abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, +	doublecomplex *work, doublereal *rwork, integer *iwork, integer *+	ifail, integer *info);+ +/* Subroutine */ int zhbtrd_(char *vect, char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, doublereal *d__, doublereal *e, +	doublecomplex *q, integer *ldq, doublecomplex *work, integer *info);+ +/* Subroutine */ int zhecon_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, doublereal *anorm, doublereal *rcond, +	doublecomplex *work, integer *info);+ +/* Subroutine */ int zheev_(char *jobz, char *uplo, integer *n, doublecomplex +	*a, integer *lda, doublereal *w, doublecomplex *work, integer *lwork, +	doublereal *rwork, integer *info);+ +/* Subroutine */ int zheevd_(char *jobz, char *uplo, integer *n, +	doublecomplex *a, integer *lda, doublereal *w, doublecomplex *work, +	integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int zheevr_(char *jobz, char *range, char *uplo, integer *n, +	doublecomplex *a, integer *lda, doublereal *vl, doublereal *vu, +	integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *+	w, doublecomplex *z__, integer *ldz, integer *isuppz, doublecomplex *+	work, integer *lwork, doublereal *rwork, integer *lrwork, integer *+	iwork, integer *liwork, integer *info);+ +/* Subroutine */ int zheevx_(char *jobz, char *range, char *uplo, integer *n, +	doublecomplex *a, integer *lda, doublereal *vl, doublereal *vu, +	integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *+	w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *+	lwork, doublereal *rwork, integer *iwork, integer *ifail, integer *+	info);+ +/* Subroutine */ int zhegs2_(integer *itype, char *uplo, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zhegst_(integer *itype, char *uplo, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zhegv_(integer *itype, char *jobz, char *uplo, integer *+	n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork,+	 integer *info);+ +/* Subroutine */ int zhegvd_(integer *itype, char *jobz, char *uplo, integer *+	n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork,+	 integer *lrwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int zhegvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, +	integer *ldb, doublereal *vl, doublereal *vu, integer *il, integer *+	iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__,+	 integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork,+	 integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int zherfs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, +	integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, +	integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work,+	 doublereal *rwork, integer *info);+ +/* Subroutine */ int zhesv_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, +	integer *ldb, doublecomplex *work, integer *lwork, integer *info);+ +/* Subroutine */ int zhesvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *+	ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x,+	 integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, +	doublecomplex *work, integer *lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zhetf2_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, integer *info);+ +/* Subroutine */ int zhetrd_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, doublereal *d__, doublereal *e, doublecomplex *tau, +	doublecomplex *work, integer *lwork, integer *info);+ +/* Subroutine */ int zhetrf_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, doublecomplex *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int zhetri_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, doublecomplex *work, integer *info);+ +/* Subroutine */ int zhetrs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, +	integer *ldb, integer *info);+ +/* Subroutine */ int zhgeqz_(char *job, char *compq, char *compz, integer *n, +	integer *ilo, integer *ihi, doublecomplex *a, integer *lda, +	doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *+	beta, doublecomplex *q, integer *ldq, doublecomplex *z__, integer *+	ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zhpcon_(char *uplo, integer *n, doublecomplex *ap, +	integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zhpev_(char *jobz, char *uplo, integer *n, doublecomplex +	*ap, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zhpevd_(char *jobz, char *uplo, integer *n, +	doublecomplex *ap, doublereal *w, doublecomplex *z__, integer *ldz, +	doublecomplex *work, integer *lwork, doublereal *rwork, integer *+	lrwork, integer *iwork, integer *liwork, integer *info);+ +/* Subroutine */ int zhpevx_(char *jobz, char *range, char *uplo, integer *n, +	doublecomplex *ap, doublereal *vl, doublereal *vu, integer *il, +	integer *iu, doublereal *abstol, integer *m, doublereal *w, +	doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *+	rwork, integer *iwork, integer *ifail, integer *info);+ +/* Subroutine */ int zhpgst_(integer *itype, char *uplo, integer *n, +	doublecomplex *ap, doublecomplex *bp, integer *info);+ +/* Subroutine */ int zhpgv_(integer *itype, char *jobz, char *uplo, integer *+	n, doublecomplex *ap, doublecomplex *bp, doublereal *w, doublecomplex +	*z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zhpgvd_(integer *itype, char *jobz, char *uplo, integer *+	n, doublecomplex *ap, doublecomplex *bp, doublereal *w, doublecomplex +	*z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal *+	rwork, integer *lrwork, integer *iwork, integer *liwork, integer *+	info);+ +/* Subroutine */ int zhpgvx_(integer *itype, char *jobz, char *range, char *+	uplo, integer *n, doublecomplex *ap, doublecomplex *bp, doublereal *+	vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, +	integer *m, doublereal *w, doublecomplex *z__, integer *ldz, +	doublecomplex *work, doublereal *rwork, integer *iwork, integer *+	ifail, integer *info);+ +/* Subroutine */ int zhprfs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex *+	b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, +	doublereal *berr, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zhpsv_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zhpsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, +	doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zhptrd_(char *uplo, integer *n, doublecomplex *ap, +	doublereal *d__, doublereal *e, doublecomplex *tau, integer *info);+ +/* Subroutine */ int zhptrf_(char *uplo, integer *n, doublecomplex *ap, +	integer *ipiv, integer *info);+ +/* Subroutine */ int zhptri_(char *uplo, integer *n, doublecomplex *ap, +	integer *ipiv, doublecomplex *work, integer *info);+ +/* Subroutine */ int zhptrs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zhsein_(char *side, char *eigsrc, char *initv, logical *+	select, integer *n, doublecomplex *h__, integer *ldh, doublecomplex *+	w, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr,+	 integer *mm, integer *m, doublecomplex *work, doublereal *rwork, +	integer *ifaill, integer *ifailr, integer *info);+ +/* Subroutine */ int zhseqr_(char *job, char *compz, integer *n, integer *ilo,+	 integer *ihi, doublecomplex *h__, integer *ldh, doublecomplex *w, +	doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zlabrd_(integer *m, integer *n, integer *nb, +	doublecomplex *a, integer *lda, doublereal *d__, doublereal *e, +	doublecomplex *tauq, doublecomplex *taup, doublecomplex *x, integer *+	ldx, doublecomplex *y, integer *ldy);+ +/* Subroutine */ int zlacgv_(integer *n, doublecomplex *x, integer *incx);+ +/* Subroutine */ int zlacon_(integer *n, doublecomplex *v, doublecomplex *x, +	doublereal *est, integer *kase);+ +/* Subroutine */ int zlacp2_(char *uplo, integer *m, integer *n, doublereal *+	a, integer *lda, doublecomplex *b, integer *ldb);+ +/* Subroutine */ int zlacpy_(char *uplo, integer *m, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb);+ +/* Subroutine */ int zlacrm_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublereal *b, integer *ldb, doublecomplex *c__, +	integer *ldc, doublereal *rwork);+ +/* Subroutine */ int zlacrt_(integer *n, doublecomplex *cx, integer *incx, +	doublecomplex *cy, integer *incy, doublecomplex *c__, doublecomplex *+	s);+ +/* Subroutine */ int zlaed0_(integer *qsiz, integer *n, doublereal *d__, +	doublereal *e, doublecomplex *q, integer *ldq, doublecomplex *qstore, +	integer *ldqs, doublereal *rwork, integer *iwork, integer *info);+ +/* Subroutine */ int zlaed7_(integer *n, integer *cutpnt, integer *qsiz, +	integer *tlvls, integer *curlvl, integer *curpbm, doublereal *d__, +	doublecomplex *q, integer *ldq, doublereal *rho, integer *indxq, +	doublereal *qstore, integer *qptr, integer *prmptr, integer *perm, +	integer *givptr, integer *givcol, doublereal *givnum, doublecomplex *+	work, doublereal *rwork, integer *iwork, integer *info);+ +/* Subroutine */ int zlaed8_(integer *k, integer *n, integer *qsiz, +	doublecomplex *q, integer *ldq, doublereal *d__, doublereal *rho, +	integer *cutpnt, doublereal *z__, doublereal *dlamda, doublecomplex *+	q2, integer *ldq2, doublereal *w, integer *indxp, integer *indx, +	integer *indxq, integer *perm, integer *givptr, integer *givcol, +	doublereal *givnum, integer *info);+ +/* Subroutine */ int zlaein_(logical *rightv, logical *noinit, integer *n, +	doublecomplex *h__, integer *ldh, doublecomplex *w, doublecomplex *v, +	doublecomplex *b, integer *ldb, doublereal *rwork, doublereal *eps3, +	doublereal *smlnum, integer *info);+ +/* Subroutine */ int zlaesy_(doublecomplex *a, doublecomplex *b, +	doublecomplex *c__, doublecomplex *rt1, doublecomplex *rt2, +	doublecomplex *evscal, doublecomplex *cs1, doublecomplex *sn1);+ +/* Subroutine */ int zlaev2_(doublecomplex *a, doublecomplex *b, +	doublecomplex *c__, doublereal *rt1, doublereal *rt2, doublereal *cs1,+	 doublecomplex *sn1);+ +/* Subroutine */ int zlags2_(logical *upper, doublereal *a1, doublecomplex *+	a2, doublereal *a3, doublereal *b1, doublecomplex *b2, doublereal *b3,+	 doublereal *csu, doublecomplex *snu, doublereal *csv, doublecomplex *+	snv, doublereal *csq, doublecomplex *snq);+ +/* Subroutine */ int zlagtm_(char *trans, integer *n, integer *nrhs, +	doublereal *alpha, doublecomplex *dl, doublecomplex *d__, +	doublecomplex *du, doublecomplex *x, integer *ldx, doublereal *beta, +	doublecomplex *b, integer *ldb);+ +/* Subroutine */ int zlahef_(char *uplo, integer *n, integer *nb, integer *kb,+	 doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *w, +	integer *ldw, integer *info);+ +/* Subroutine */ int zlahqr_(logical *wantt, logical *wantz, integer *n, +	integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, +	doublecomplex *w, integer *iloz, integer *ihiz, doublecomplex *z__, +	integer *ldz, integer *info);+ +/* Subroutine */ int zlahrd_(integer *n, integer *k, integer *nb, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *t, +	integer *ldt, doublecomplex *y, integer *ldy);+ +/* Subroutine */ int zlaic1_(integer *job, integer *j, doublecomplex *x, +	doublereal *sest, doublecomplex *w, doublecomplex *gamma, doublereal *+	sestpr, doublecomplex *s, doublecomplex *c__);+ +/* Subroutine */ int zlals0_(integer *icompq, integer *nl, integer *nr, +	integer *sqre, integer *nrhs, doublecomplex *b, integer *ldb, +	doublecomplex *bx, integer *ldbx, integer *perm, integer *givptr, +	integer *givcol, integer *ldgcol, doublereal *givnum, integer *ldgnum,+	 doublereal *poles, doublereal *difl, doublereal *difr, doublereal *+	z__, integer *k, doublereal *c__, doublereal *s, doublereal *rwork, +	integer *info);+ +/* Subroutine */ int zlalsa_(integer *icompq, integer *smlsiz, integer *n, +	integer *nrhs, doublecomplex *b, integer *ldb, doublecomplex *bx, +	integer *ldbx, doublereal *u, integer *ldu, doublereal *vt, integer *+	k, doublereal *difl, doublereal *difr, doublereal *z__, doublereal *+	poles, integer *givptr, integer *givcol, integer *ldgcol, integer *+	perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal *+	rwork, integer *iwork, integer *info);+ +/* Subroutine */ int zlapll_(integer *n, doublecomplex *x, integer *incx, +	doublecomplex *y, integer *incy, doublereal *ssmin);+ +/* Subroutine */ int zlapmt_(logical *forwrd, integer *m, integer *n, +	doublecomplex *x, integer *ldx, integer *k);+ +/* Subroutine */ int zlaqgb_(integer *m, integer *n, integer *kl, integer *ku,+	 doublecomplex *ab, integer *ldab, doublereal *r__, doublereal *c__, +	doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed);+ +/* Subroutine */ int zlaqge_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, +	doublereal *colcnd, doublereal *amax, char *equed);+ +/* Subroutine */ int zlaqhb_(char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, +	doublereal *amax, char *equed);+ +/* Subroutine */ int zlaqhe_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, doublereal *s, doublereal *scond, doublereal *amax, +	char *equed);+ +/* Subroutine */ int zlaqhp_(char *uplo, integer *n, doublecomplex *ap, +	doublereal *s, doublereal *scond, doublereal *amax, char *equed);+ +/* Subroutine */ int zlaqp2_(integer *m, integer *n, integer *offset, +	doublecomplex *a, integer *lda, integer *jpvt, doublecomplex *tau, +	doublereal *vn1, doublereal *vn2, doublecomplex *work);+ +/* Subroutine */ int zlaqps_(integer *m, integer *n, integer *offset, integer +	*nb, integer *kb, doublecomplex *a, integer *lda, integer *jpvt, +	doublecomplex *tau, doublereal *vn1, doublereal *vn2, doublecomplex *+	auxv, doublecomplex *f, integer *ldf);+ +/* Subroutine */ int zlaqsb_(char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, +	doublereal *amax, char *equed);+ +/* Subroutine */ int zlaqsp_(char *uplo, integer *n, doublecomplex *ap, +	doublereal *s, doublereal *scond, doublereal *amax, char *equed);+ +/* Subroutine */ int zlaqsy_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, doublereal *s, doublereal *scond, doublereal *amax, +	char *equed);+ +/* Subroutine */ int zlar1v_(integer *n, integer *b1, integer *bn, doublereal +	*sigma, doublereal *d__, doublereal *l, doublereal *ld, doublereal *+	lld, doublereal *gersch, doublecomplex *z__, doublereal *ztz, +	doublereal *mingma, integer *r__, integer *isuppz, doublereal *work);+ +/* Subroutine */ int zlar2v_(integer *n, doublecomplex *x, doublecomplex *y, +	doublecomplex *z__, integer *incx, doublereal *c__, doublecomplex *s, +	integer *incc);+ +/* Subroutine */ int zlarcm_(integer *m, integer *n, doublereal *a, integer *+	lda, doublecomplex *b, integer *ldb, doublecomplex *c__, integer *ldc,+	 doublereal *rwork);+ +/* Subroutine */ int zlarf_(char *side, integer *m, integer *n, doublecomplex +	*v, integer *incv, doublecomplex *tau, doublecomplex *c__, integer *+	ldc, doublecomplex *work);+ +/* Subroutine */ int zlarfb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, doublecomplex *v, integer +	*ldv, doublecomplex *t, integer *ldt, doublecomplex *c__, integer *+	ldc, doublecomplex *work, integer *ldwork);+ +/* Subroutine */ int zlarfg_(integer *n, doublecomplex *alpha, doublecomplex *+	x, integer *incx, doublecomplex *tau);+ +/* Subroutine */ int zlarft_(char *direct, char *storev, integer *n, integer *+	k, doublecomplex *v, integer *ldv, doublecomplex *tau, doublecomplex *+	t, integer *ldt);+ +/* Subroutine */ int zlarfx_(char *side, integer *m, integer *n, +	doublecomplex *v, doublecomplex *tau, doublecomplex *c__, integer *+	ldc, doublecomplex *work);+ +/* Subroutine */ int zlargv_(integer *n, doublecomplex *x, integer *incx, +	doublecomplex *y, integer *incy, doublereal *c__, integer *incc);+ +/* Subroutine */ int zlarnv_(integer *idist, integer *iseed, integer *n, +	doublecomplex *x);+ +/* Subroutine */ int zlarrv_(integer *n, doublereal *d__, doublereal *l, +	integer *isplit, integer *m, doublereal *w, integer *iblock, +	doublereal *gersch, doublereal *tol, doublecomplex *z__, integer *ldz,+	 integer *isuppz, doublereal *work, integer *iwork, integer *info);+ +/* Subroutine */ int zlartg_(doublecomplex *f, doublecomplex *g, doublereal *+	cs, doublecomplex *sn, doublecomplex *r__);+ +/* Subroutine */ int zlartv_(integer *n, doublecomplex *x, integer *incx, +	doublecomplex *y, integer *incy, doublereal *c__, doublecomplex *s, +	integer *incc);+ +/* Subroutine */ int zlarz_(char *side, integer *m, integer *n, integer *l, +	doublecomplex *v, integer *incv, doublecomplex *tau, doublecomplex *+	c__, integer *ldc, doublecomplex *work);+ +/* Subroutine */ int zlarzb_(char *side, char *trans, char *direct, char *+	storev, integer *m, integer *n, integer *k, integer *l, doublecomplex +	*v, integer *ldv, doublecomplex *t, integer *ldt, doublecomplex *c__, +	integer *ldc, doublecomplex *work, integer *ldwork);+ +/* Subroutine */ int zlarzt_(char *direct, char *storev, integer *n, integer *+	k, doublecomplex *v, integer *ldv, doublecomplex *tau, doublecomplex *+	t, integer *ldt);+ +/* Subroutine */ int zlascl_(char *type__, integer *kl, integer *ku, +	doublereal *cfrom, doublereal *cto, integer *m, integer *n, +	doublecomplex *a, integer *lda, integer *info);+ +/* Subroutine */ int zlaset_(char *uplo, integer *m, integer *n, +	doublecomplex *alpha, doublecomplex *beta, doublecomplex *a, integer *+	lda);+ +/* Subroutine */ int zlasr_(char *side, char *pivot, char *direct, integer *m,+	 integer *n, doublereal *c__, doublereal *s, doublecomplex *a, +	integer *lda);+ +/* Subroutine */ int zlassq_(integer *n, doublecomplex *x, integer *incx, +	doublereal *scale, doublereal *sumsq);+ +/* Subroutine */ int zlaswp_(integer *n, doublecomplex *a, integer *lda, +	integer *k1, integer *k2, integer *ipiv, integer *incx);+ +/* Subroutine */ int zlasyf_(char *uplo, integer *n, integer *nb, integer *kb,+	 doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *w, +	integer *ldw, integer *info);+ +/* Subroutine */ int zlatbs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, integer *kd, doublecomplex *ab, integer *ldab, +	doublecomplex *x, doublereal *scale, doublereal *cnorm, integer *info);+ +/* Subroutine */ int zlatdf_(integer *ijob, integer *n, doublecomplex *z__, +	integer *ldz, doublecomplex *rhs, doublereal *rdsum, doublereal *+	rdscal, integer *ipiv, integer *jpiv);+ +/* Subroutine */ int zlatps_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, doublecomplex *ap, doublecomplex *x, doublereal *+	scale, doublereal *cnorm, integer *info);+ +/* Subroutine */ int zlatrd_(char *uplo, integer *n, integer *nb, +	doublecomplex *a, integer *lda, doublereal *e, doublecomplex *tau, +	doublecomplex *w, integer *ldw);+ +/* Subroutine */ int zlatrs_(char *uplo, char *trans, char *diag, char *+	normin, integer *n, doublecomplex *a, integer *lda, doublecomplex *x, +	doublereal *scale, doublereal *cnorm, integer *info);+ +/* Subroutine */ int zlatrz_(integer *m, integer *n, integer *l, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work);+ +/* Subroutine */ int zlatzm_(char *side, integer *m, integer *n, +	doublecomplex *v, integer *incv, doublecomplex *tau, doublecomplex *+	c1, doublecomplex *c2, integer *ldc, doublecomplex *work);+ +/* Subroutine */ int zlauu2_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *info);+ +/* Subroutine */ int zlauum_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *info);+ +/* Subroutine */ int zpbcon_(char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, doublereal *anorm, doublereal *+	rcond, doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zpbequ_(char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, +	doublereal *amax, integer *info);+ +/* Subroutine */ int zpbrfs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *+	ldafb, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx,+	 doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *+	rwork, integer *info);+ +/* Subroutine */ int zpbstf_(char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, integer *info);+ +/* Subroutine */ int zpbsv_(char *uplo, integer *n, integer *kd, integer *+	nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer *+	ldb, integer *info);+ +/* Subroutine */ int zpbsvx_(char *fact, char *uplo, integer *n, integer *kd, +	integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, +	integer *ldafb, char *equed, doublereal *s, doublecomplex *b, integer +	*ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *+	ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, +	integer *info);+ +/* Subroutine */ int zpbtf2_(char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, integer *info);+ +/* Subroutine */ int zpbtrf_(char *uplo, integer *n, integer *kd, +	doublecomplex *ab, integer *ldab, integer *info);+ +/* Subroutine */ int zpbtrs_(char *uplo, integer *n, integer *kd, integer *+	nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer *+	ldb, integer *info);+ +/* Subroutine */ int zpocon_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, doublereal *anorm, doublereal *rcond, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zpoequ_(integer *n, doublecomplex *a, integer *lda, +	doublereal *s, doublereal *scond, doublereal *amax, integer *info);+ +/* Subroutine */ int zporfs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, +	doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *+	rwork, integer *info);+ +/* Subroutine */ int zposv_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zposvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *+	ldaf, char *equed, doublereal *s, doublecomplex *b, integer *ldb, +	doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, +	doublereal *berr, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zpotf2_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *info);+ +/* Subroutine */ int zpotrf_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *info);+ +/* Subroutine */ int zpotri_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *info);+ +/* Subroutine */ int zpotrs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zppcon_(char *uplo, integer *n, doublecomplex *ap, +	doublereal *anorm, doublereal *rcond, doublecomplex *work, doublereal +	*rwork, integer *info);+ +/* Subroutine */ int zppequ_(char *uplo, integer *n, doublecomplex *ap, +	doublereal *s, doublereal *scond, doublereal *amax, integer *info);+ +/* Subroutine */ int zpprfs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, doublecomplex *afp, doublecomplex *b, integer *ldb,+	 doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zppsv_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, doublecomplex *b, integer *ldb, integer *info);+ +/* Subroutine */ int zppsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublecomplex *ap, doublecomplex *afp, char *equed, doublereal *+	s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zpptrf_(char *uplo, integer *n, doublecomplex *ap, +	integer *info);+ +/* Subroutine */ int zpptri_(char *uplo, integer *n, doublecomplex *ap, +	integer *info);+ +/* Subroutine */ int zpptrs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, doublecomplex *b, integer *ldb, integer *info);+ +/* Subroutine */ int zptcon_(integer *n, doublereal *d__, doublecomplex *e, +	doublereal *anorm, doublereal *rcond, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zptrfs_(char *uplo, integer *n, integer *nrhs, +	doublereal *d__, doublecomplex *e, doublereal *df, doublecomplex *ef, +	doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *+	rwork, integer *info);+ +/* Subroutine */ int zptsv_(integer *n, integer *nrhs, doublereal *d__, +	doublecomplex *e, doublecomplex *b, integer *ldb, integer *info);+ +/* Subroutine */ int zptsvx_(char *fact, integer *n, integer *nrhs, +	doublereal *d__, doublecomplex *e, doublereal *df, doublecomplex *ef, +	doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zpttrf_(integer *n, doublereal *d__, doublecomplex *e, +	integer *info);+ +/* Subroutine */ int zpttrs_(char *uplo, integer *n, integer *nrhs, +	doublereal *d__, doublecomplex *e, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zptts2_(integer *iuplo, integer *n, integer *nrhs, +	doublereal *d__, doublecomplex *e, doublecomplex *b, integer *ldb);+ +/* Subroutine */ int zrot_(integer *n, doublecomplex *cx, integer *incx, +	doublecomplex *cy, integer *incy, doublereal *c__, doublecomplex *s);+ +/* Subroutine */ int zspcon_(char *uplo, integer *n, doublecomplex *ap, +	integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zspmv_(char *uplo, integer *n, doublecomplex *alpha, +	doublecomplex *ap, doublecomplex *x, integer *incx, doublecomplex *+	beta, doublecomplex *y, integer *incy);+ +/* Subroutine */ int zspr_(char *uplo, integer *n, doublecomplex *alpha, +	doublecomplex *x, integer *incx, doublecomplex *ap);+ +/* Subroutine */ int zsprfs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex *+	b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, +	doublereal *berr, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int zspsv_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zspsvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, +	doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int zsptrf_(char *uplo, integer *n, doublecomplex *ap, +	integer *ipiv, integer *info);+ +/* Subroutine */ int zsptri_(char *uplo, integer *n, doublecomplex *ap, +	integer *ipiv, doublecomplex *work, integer *info);+ +/* Subroutine */ int zsptrs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int zstedc_(char *compz, integer *n, doublereal *d__, +	doublereal *e, doublecomplex *z__, integer *ldz, doublecomplex *work, +	integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, +	integer *liwork, integer *info);+ +/* Subroutine */ int zstein_(integer *n, doublereal *d__, doublereal *e, +	integer *m, doublereal *w, integer *iblock, integer *isplit, +	doublecomplex *z__, integer *ldz, doublereal *work, integer *iwork, +	integer *ifail, integer *info);+ +/* Subroutine */ int zsteqr_(char *compz, integer *n, doublereal *d__, +	doublereal *e, doublecomplex *z__, integer *ldz, doublereal *work, +	integer *info);+ +/* Subroutine */ int zsycon_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, doublereal *anorm, doublereal *rcond, +	doublecomplex *work, integer *info);+ +/* Subroutine */ int zsymv_(char *uplo, integer *n, doublecomplex *alpha, +	doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, +	doublecomplex *beta, doublecomplex *y, integer *incy);+ +/* Subroutine */ int zsyr_(char *uplo, integer *n, doublecomplex *alpha, +	doublecomplex *x, integer *incx, doublecomplex *a, integer *lda);+ +/* Subroutine */ int zsyrfs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, +	integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, +	integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work,+	 doublereal *rwork, integer *info);+ +/* Subroutine */ int zsysv_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, +	integer *ldb, doublecomplex *work, integer *lwork, integer *info);+ +/* Subroutine */ int zsysvx_(char *fact, char *uplo, integer *n, integer *+	nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *+	ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x,+	 integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, +	doublecomplex *work, integer *lwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int zsytf2_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, integer *info);+ +/* Subroutine */ int zsytrf_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, doublecomplex *work, integer *lwork, +	integer *info);+ +/* Subroutine */ int zsytri_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, integer *ipiv, doublecomplex *work, integer *info);+ +/* Subroutine */ int zsytrs_(char *uplo, integer *n, integer *nrhs, +	doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, +	integer *ldb, integer *info);+ +/* Subroutine */ int ztbcon_(char *norm, char *uplo, char *diag, integer *n, +	integer *kd, doublecomplex *ab, integer *ldab, doublereal *rcond, +	doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int ztbrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, doublecomplex *ab, integer *ldab, +	doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, +	doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *+	rwork, integer *info);+ +/* Subroutine */ int ztbtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *kd, integer *nrhs, doublecomplex *ab, integer *ldab, +	doublecomplex *b, integer *ldb, integer *info);+ +/* Subroutine */ int ztgevc_(char *side, char *howmny, logical *select, +	integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer +	*ldb, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *+	ldvr, integer *mm, integer *m, doublecomplex *work, doublereal *rwork,+	 integer *info);+ +/* Subroutine */ int ztgex2_(logical *wantq, logical *wantz, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *q, integer *ldq, doublecomplex *z__, integer *ldz, +	integer *j1, integer *info);+ +/* Subroutine */ int ztgexc_(logical *wantq, logical *wantz, integer *n, +	doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *q, integer *ldq, doublecomplex *z__, integer *ldz, +	integer *ifst, integer *ilst, integer *info);+ +/* Subroutine */ int ztgsen_(integer *ijob, logical *wantq, logical *wantz, +	logical *select, integer *n, doublecomplex *a, integer *lda, +	doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *+	beta, doublecomplex *q, integer *ldq, doublecomplex *z__, integer *+	ldz, integer *m, doublereal *pl, doublereal *pr, doublereal *dif, +	doublecomplex *work, integer *lwork, integer *iwork, integer *liwork, +	integer *info);+ +/* Subroutine */ int ztgsja_(char *jobu, char *jobv, char *jobq, integer *m, +	integer *p, integer *n, integer *k, integer *l, doublecomplex *a, +	integer *lda, doublecomplex *b, integer *ldb, doublereal *tola, +	doublereal *tolb, doublereal *alpha, doublereal *beta, doublecomplex *+	u, integer *ldu, doublecomplex *v, integer *ldv, doublecomplex *q, +	integer *ldq, doublecomplex *work, integer *ncycle, integer *info);+ +/* Subroutine */ int ztgsna_(char *job, char *howmny, logical *select, +	integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer +	*ldb, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *+	ldvr, doublereal *s, doublereal *dif, integer *mm, integer *m, +	doublecomplex *work, integer *lwork, integer *iwork, integer *info);+ +/* Subroutine */ int ztgsy2_(char *trans, integer *ijob, integer *m, integer *+	n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *c__, integer *ldc, doublecomplex *d__, integer *ldd, +	doublecomplex *e, integer *lde, doublecomplex *f, integer *ldf, +	doublereal *scale, doublereal *rdsum, doublereal *rdscal, integer *+	info);+ +/* Subroutine */ int ztgsyl_(char *trans, integer *ijob, integer *m, integer *+	n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, +	doublecomplex *c__, integer *ldc, doublecomplex *d__, integer *ldd, +	doublecomplex *e, integer *lde, doublecomplex *f, integer *ldf, +	doublereal *scale, doublereal *dif, doublecomplex *work, integer *+	lwork, integer *iwork, integer *info);+ +/* Subroutine */ int ztpcon_(char *norm, char *uplo, char *diag, integer *n, +	doublecomplex *ap, doublereal *rcond, doublecomplex *work, doublereal +	*rwork, integer *info);+ +/* Subroutine */ int ztprfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, +	doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, +	doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int ztptri_(char *uplo, char *diag, integer *n, +	doublecomplex *ap, integer *info);+ +/* Subroutine */ int ztptrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, +	integer *info);+ +/* Subroutine */ int ztrcon_(char *norm, char *uplo, char *diag, integer *n, +	doublecomplex *a, integer *lda, doublereal *rcond, doublecomplex *+	work, doublereal *rwork, integer *info);+ +/* Subroutine */ int ztrevc_(char *side, char *howmny, logical *select, +	integer *n, doublecomplex *t, integer *ldt, doublecomplex *vl, +	integer *ldvl, doublecomplex *vr, integer *ldvr, integer *mm, integer +	*m, doublecomplex *work, doublereal *rwork, integer *info);+ +/* Subroutine */ int ztrexc_(char *compq, integer *n, doublecomplex *t, +	integer *ldt, doublecomplex *q, integer *ldq, integer *ifst, integer *+	ilst, integer *info);+ +/* Subroutine */ int ztrrfs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, +	integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, +	doublereal *berr, doublecomplex *work, doublereal *rwork, integer *+	info);+ +/* Subroutine */ int ztrsen_(char *job, char *compq, logical *select, integer +	*n, doublecomplex *t, integer *ldt, doublecomplex *q, integer *ldq, +	doublecomplex *w, integer *m, doublereal *s, doublereal *sep, +	doublecomplex *work, integer *lwork, integer *info);+ +/* Subroutine */ int ztrsna_(char *job, char *howmny, logical *select, +	integer *n, doublecomplex *t, integer *ldt, doublecomplex *vl, +	integer *ldvl, doublecomplex *vr, integer *ldvr, doublereal *s, +	doublereal *sep, integer *mm, integer *m, doublecomplex *work, +	integer *ldwork, doublereal *rwork, integer *info);+ +/* Subroutine */ int ztrsyl_(char *trana, char *tranb, integer *isgn, integer +	*m, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, +	integer *ldb, doublecomplex *c__, integer *ldc, doublereal *scale, +	integer *info);+ +/* Subroutine */ int ztrti2_(char *uplo, char *diag, integer *n, +	doublecomplex *a, integer *lda, integer *info);+ +/* Subroutine */ int ztrtri_(char *uplo, char *diag, integer *n, +	doublecomplex *a, integer *lda, integer *info);+ +/* Subroutine */ int ztrtrs_(char *uplo, char *trans, char *diag, integer *n, +	integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, +	integer *ldb, integer *info);+ +/* Subroutine */ int ztzrqf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, integer *info);+ +/* Subroutine */ int ztzrzf_(integer *m, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zung2l_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zung2r_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zungbr_(char *vect, integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zunghr_(integer *n, integer *ilo, integer *ihi, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zungl2_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zunglq_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zungql_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zungqr_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zungr2_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zungrq_(integer *m, integer *n, integer *k, +	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zungtr_(char *uplo, integer *n, doublecomplex *a, +	integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zunm2l_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);+ +/* Subroutine */ int zunm2r_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);+ +/* Subroutine */ int zunmbr_(char *vect, char *side, char *trans, integer *m, +	integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex +	*tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *+	lwork, integer *info);+ +/* Subroutine */ int zunmhr_(char *side, char *trans, integer *m, integer *n, +	integer *ilo, integer *ihi, doublecomplex *a, integer *lda, +	doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *+	work, integer *lwork, integer *info);+ +/* Subroutine */ int zunml2_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);+ +/* Subroutine */ int zunmlq_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zunmql_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zunmqr_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zunmr2_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);+ +/* Subroutine */ int zunmr3_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex +	*tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *+	info);+ +/* Subroutine */ int zunmrq_(char *side, char *trans, integer *m, integer *n, +	integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zunmrz_(char *side, char *trans, integer *m, integer *n, +	integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex +	*tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *+	lwork, integer *info);+ +/* Subroutine */ int zunmtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, +	doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork,+	 integer *info);+ +/* Subroutine */ int zupgtr_(char *uplo, integer *n, doublecomplex *ap, +	doublecomplex *tau, doublecomplex *q, integer *ldq, doublecomplex *+	work, integer *info);+ +/* Subroutine */ int zupmtr_(char *side, char *uplo, char *trans, integer *m, +	integer *n, doublecomplex *ap, doublecomplex *tau, doublecomplex *c__,+	 integer *ldc, doublecomplex *work, integer *info);++#endif /* __CLAPACK_H */
+ lib/Numeric/LinearAlgebra/LAPACK/f2c.h view
@@ -0,0 +1,223 @@+/* f2c.h  --  Standard Fortran to C header file */++/**  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."++	- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */++#ifndef F2C_INCLUDE+#define F2C_INCLUDE++typedef long int integer;+typedef unsigned long int uinteger;+typedef char *address;+typedef short int shortint;+typedef float real;+typedef double doublereal;+typedef struct { real r, i; } complex;+typedef struct { doublereal r, i; } doublecomplex;+typedef long int logical;+typedef short int shortlogical;+typedef char logical1;+typedef char integer1;+#ifdef INTEGER_STAR_8	/* Adjust for integer*8. */+typedef long long longint;		/* system-dependent */+typedef unsigned long long ulongint;	/* system-dependent */+#define qbit_clear(a,b)	((a) & ~((ulongint)1 << (b)))+#define qbit_set(a,b)	((a) |  ((ulongint)1 << (b)))+#endif++#define TRUE_ (1)+#define FALSE_ (0)++/* Extern is for use with -E */+#ifndef Extern+#define Extern extern+#endif++/* I/O stuff */++#ifdef f2c_i2+/* for -i2 */+typedef short flag;+typedef short ftnlen;+typedef short ftnint;+#else+typedef long int flag;+typedef long int ftnlen;+typedef long int ftnint;+#endif++/*external read, write*/+typedef struct+{	flag cierr;+	ftnint ciunit;+	flag ciend;+	char *cifmt;+	ftnint cirec;+} cilist;++/*internal read, write*/+typedef struct+{	flag icierr;+	char *iciunit;+	flag iciend;+	char *icifmt;+	ftnint icirlen;+	ftnint icirnum;+} icilist;++/*open*/+typedef struct+{	flag oerr;+	ftnint ounit;+	char *ofnm;+	ftnlen ofnmlen;+	char *osta;+	char *oacc;+	char *ofm;+	ftnint orl;+	char *oblnk;+} olist;++/*close*/+typedef struct+{	flag cerr;+	ftnint cunit;+	char *csta;+} cllist;++/*rewind, backspace, endfile*/+typedef struct+{	flag aerr;+	ftnint aunit;+} alist;++/* inquire */+typedef struct+{	flag inerr;+	ftnint inunit;+	char *infile;+	ftnlen infilen;+	ftnint	*inex;	/*parameters in standard's order*/+	ftnint	*inopen;+	ftnint	*innum;+	ftnint	*innamed;+	char	*inname;+	ftnlen	innamlen;+	char	*inacc;+	ftnlen	inacclen;+	char	*inseq;+	ftnlen	inseqlen;+	char 	*indir;+	ftnlen	indirlen;+	char	*infmt;+	ftnlen	infmtlen;+	char	*inform;+	ftnint	informlen;+	char	*inunf;+	ftnlen	inunflen;+	ftnint	*inrecl;+	ftnint	*innrec;+	char	*inblank;+	ftnlen	inblanklen;+} inlist;++#define VOID void++union Multitype {	/* for multiple entry points */+	integer1 g;+	shortint h;+	integer i;+	/* longint j; */+	real r;+	doublereal d;+	complex c;+	doublecomplex z;+	};++typedef union Multitype Multitype;++/*typedef long int Long;*/	/* No longer used; formerly in Namelist */++struct Vardesc {	/* for Namelist */+	char *name;+	char *addr;+	ftnlen *dims;+	int  type;+	};+typedef struct Vardesc Vardesc;++struct Namelist {+	char *name;+	Vardesc **vars;+	int nvars;+	};+typedef struct Namelist Namelist;++#define abs(x) ((x) >= 0 ? (x) : -(x))+#define dabs(x) (doublereal)abs(x)+#define min(a,b) ((a) <= (b) ? (a) : (b))+#define max(a,b) ((a) >= (b) ? (a) : (b))+#define dmin(a,b) (doublereal)min(a,b)+#define dmax(a,b) (doublereal)max(a,b)+#define bit_test(a,b)	((a) >> (b) & 1)+#define bit_clear(a,b)	((a) & ~((uinteger)1 << (b)))+#define bit_set(a,b)	((a) |  ((uinteger)1 << (b)))++/* procedure parameter types for -A and -C++ */++#define F2C_proc_par_types 1+#ifdef __cplusplus+typedef int /* Unknown procedure type */ (*U_fp)(...);+typedef shortint (*J_fp)(...);+typedef integer (*I_fp)(...);+typedef real (*R_fp)(...);+typedef doublereal (*D_fp)(...), (*E_fp)(...);+typedef /* Complex */ VOID (*C_fp)(...);+typedef /* Double Complex */ VOID (*Z_fp)(...);+typedef logical (*L_fp)(...);+typedef shortlogical (*K_fp)(...);+typedef /* Character */ VOID (*H_fp)(...);+typedef /* Subroutine */ int (*S_fp)(...);+#else+typedef int /* Unknown procedure type */ (*U_fp)();+typedef shortint (*J_fp)();+typedef integer (*I_fp)();+typedef real (*R_fp)();+typedef doublereal (*D_fp)(), (*E_fp)();+typedef /* Complex */ VOID (*C_fp)();+typedef /* Double Complex */ VOID (*Z_fp)();+typedef logical (*L_fp)();+typedef shortlogical (*K_fp)();+typedef /* Character */ VOID (*H_fp)();+typedef /* Subroutine */ int (*S_fp)();+#endif+/* E_fp is for real functions when -R is not specified */+typedef VOID C_f;	/* complex function */+typedef VOID H_f;	/* character function */+typedef VOID Z_f;	/* double complex function */+typedef doublereal E_f;	/* real function with -R not specified */++/* undef any lower-case symbols that your C compiler predefines, e.g.: */++#ifndef Skip_f2c_Undefs+#undef cray+#undef gcos+#undef mc68010+#undef mc68020+#undef mips+#undef pdp11+#undef sgi+#undef sparc+#undef sun+#undef sun2+#undef sun3+#undef sun4+#undef u370+#undef u3b+#undef u3b2+#undef u3b5+#undef unix+#undef vax+#endif+#endif
+ lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c view
@@ -0,0 +1,770 @@+#include <stdio.h>+#include <stdlib.h>+#include <string.h>+#include <math.h>+#include <time.h>+#include "lapack-aux.h"++#define MACRO(B) do {B} while (0)+#define ERROR(CODE) MACRO(return CODE;)+#define REQUIRES(COND, CODE) MACRO(if(!(COND)) {ERROR(CODE);})++#define MIN(A,B) ((A)<(B)?(A):(B))+#define MAX(A,B) ((A)>(B)?(A):(B))+ +#ifdef DBGL+#define DEBUGMSG(M) printf("LAPACK Wrapper "M"\n: "); size_t t0 = time(NULL);+#define OK MACRO(printf("%ld s\n",time(0)-t0); return 0;);+#else+#define DEBUGMSG(M)+#define OK return 0;+#endif++#define CHECK(RES,CODE) MACRO(if(RES) return CODE;)++#define BAD_SIZE 2000+#define BAD_CODE 2001+#define MEM      2002+#define BAD_FILE 2003+#define SINGULAR 2004+#define NOCONVER 2005+#define NODEFPOS 2006+#define NOSPRTD  2007+++//////////////////// real svd ////////////////////////////////////++int svd_l_R(KDMAT(a),DMAT(u), DVEC(s),DMAT(v)) {+    integer m = ar;+    integer n = ac;+    integer q = MIN(m,n);+    REQUIRES(ur==m && uc==m && sn==q && vr==n && vc==n,BAD_SIZE);+    DEBUGMSG("svd_l_R");+    double *B = (double*)malloc(m*n*sizeof(double));+    CHECK(!B,MEM);+    memcpy(B,ap,m*n*sizeof(double));+    integer lwork = -1;+    integer res;+    // ask for optimal lwork+    double ans;+    //printf("ask zgesvd\n");+    char* job = "A";+    dgesvd_ (job,job,+             &m,&n,B,&m,+             sp,+             up,&m,+             vp,&n,+             &ans, &lwork,+             &res);+    lwork = ceil(ans);+    //printf("ans = %d\n",lwork);+    double * work = (double*)malloc(lwork*sizeof(double));+    CHECK(!work,MEM);+    //printf("dgesdd\n");+    dgesvd_ (job,job,+             &m,&n,B,&m,+             sp,+             up,&m,+             vp,&n,+             work, &lwork,+             &res);+    CHECK(res,res);+    free(work);+    free(B);+    OK+}++// (alternative version)++int svd_l_Rdd(KDMAT(a),DMAT(u), DVEC(s),DMAT(v)) {+    integer m = ar;+    integer n = ac;+    integer q = MIN(m,n);+    REQUIRES(ur==m && uc==m && sn==q && vr==n && vc==n,BAD_SIZE);+    DEBUGMSG("svd_l_Rdd");+    double *B = (double*)malloc(m*n*sizeof(double));+    CHECK(!B,MEM);+    memcpy(B,ap,m*n*sizeof(double));+    integer* iwk = (integer*) malloc(8*q*sizeof(int));+    CHECK(!iwk,MEM);+    integer lwk = -1;+    integer res;+    // ask for optimal lwk+    double ans;+    //printf("ask dgesdd\n");+    dgesdd_ ("A",&m,&n,B,&m,sp,up,&m,vp,&n,&ans,&lwk,iwk,&res);+    lwk = 2*ceil(ans); // ????? otherwise 50x100 rejects lwk+    //printf("lwk = %d\n",lwk);+    double * workv = (double*)malloc(lwk*sizeof(double));+    CHECK(!workv,MEM);+    //printf("dgesdd\n");+    dgesdd_ ("A",&m,&n,B,&m,sp,up,&m,vp,&n,workv,&lwk,iwk,&res);+    CHECK(res,res);+    free(iwk);+    free(workv);+    free(B);+    OK+}++//////////////////// complex svd ////////////////////////////////////++// not in clapack.h++int zgesvd_(char *jobu, char *jobvt, integer *m, integer *n, +    doublecomplex *a, integer *lda, doublereal *s, doublecomplex *u, +    integer *ldu, doublecomplex *vt, integer *ldvt, doublecomplex *work, +    integer *lwork, doublereal *rwork, integer *info);++int svd_l_C(KCMAT(a),CMAT(u), DVEC(s),CMAT(v)) {+    integer m = ar;+    integer n = ac;+    integer q = MIN(m,n);+    REQUIRES(ur==m && uc==m && sn==q && vr==n && vc==n,BAD_SIZE);+    DEBUGMSG("svd_l_C");+    double *B = (double*)malloc(2*m*n*sizeof(double));+    CHECK(!B,MEM);+    memcpy(B,ap,m*n*2*sizeof(double));++    double *rwork = (double*) malloc(5*q*sizeof(double));+    CHECK(!rwork,MEM);+    integer lwork = -1;+    integer res;+    // ask for optimal lwork+    doublecomplex ans;+    //printf("ask zgesvd\n");+    char* job = "A";+    zgesvd_ (job,job,+             &m,&n,(doublecomplex*)B,&m,+             sp,+             (doublecomplex*)up,&m,+             (doublecomplex*)vp,&n,+             &ans, &lwork,+             rwork,+             &res);+    lwork = ceil(ans.r);+    //printf("ans = %d\n",lwork);+    doublecomplex * work = (doublecomplex*)malloc(lwork*2*sizeof(double));+    CHECK(!work,MEM);+    //printf("zgesvd\n");+    zgesvd_ (job,job,+             &m,&n,(doublecomplex*)B,&m,+             sp,+             (doublecomplex*)up,&m,+             (doublecomplex*)vp,&n,+             work, &lwork,+             rwork,+             &res);+    CHECK(res,res);+    free(work);+    free(rwork);+    free(B);+    OK+}++++//////////////////// general complex eigensystem ////////////++int eig_l_C(KCMAT(a),CMAT(u), CVEC(s),CMAT(v)) {+    integer n = ar;+    REQUIRES(n>=2 && ac==n && (ur==1 || (ur==n && uc==n)) && sn==n && (vr==1 || (vr==n && vc==n)),BAD_SIZE);+    DEBUGMSG("eig_l_C");+    double *B = (double*)malloc(2*n*n*sizeof(double));+    CHECK(!B,MEM);+    memcpy(B,ap,n*n*2*sizeof(double));++    double *rwork = (double*) malloc(2*n*sizeof(double));+    CHECK(!rwork,MEM);+    integer lwork = -1;+    char jobvl = ur==1?'N':'V';+    char jobvr = vr==1?'N':'V';+    integer res;+    // ask for optimal lwork+    doublecomplex ans;+    //printf("ask zgeev\n");+    zgeev_  (&jobvl,&jobvr,+             &n,(doublecomplex*)B,&n,+             (doublecomplex*)sp,+             (doublecomplex*)up,&n,+             (doublecomplex*)vp,&n,+             &ans, &lwork,+             rwork,+             &res);+    lwork = ceil(ans.r);+    //printf("ans = %d\n",lwork);+    doublecomplex * work = (doublecomplex*)malloc(lwork*2*sizeof(double));+    CHECK(!work,MEM);+    //printf("zgeev\n");+    zgeev_  (&jobvl,&jobvr,+             &n,(doublecomplex*)B,&n,+             (doublecomplex*)sp,+             (doublecomplex*)up,&n,+             (doublecomplex*)vp,&n,+             work, &lwork,+             rwork,+             &res);+    CHECK(res,res);+    free(work);+    free(rwork);+    free(B);+    OK+}++++//////////////////// general real eigensystem ////////////++int eig_l_R(KDMAT(a),DMAT(u), CVEC(s),DMAT(v)) {+    integer n = ar;+    REQUIRES(n>=2 && ac == n && (ur==1 || (ur==n && uc==n)) && sn==n && (vr==1 || (vr==n && vc==n)),BAD_SIZE);+    DEBUGMSG("eig_l_R");+    double *B = (double*)malloc(n*n*sizeof(double));+    CHECK(!B,MEM);+    memcpy(B,ap,n*n*sizeof(double));+    integer lwork = -1;+    char jobvl = ur==1?'N':'V';+    char jobvr = vr==1?'N':'V';+    integer res;+    // ask for optimal lwork+    double ans;+    //printf("ask dgeev\n");+    dgeev_  (&jobvl,&jobvr,+             &n,B,&n,+             sp, sp+n,+             up,&n,+             vp,&n,+             &ans, &lwork,+             &res);+    lwork = ceil(ans);+    //printf("ans = %d\n",lwork);+    double * work = (double*)malloc(lwork*sizeof(double));+    CHECK(!work,MEM);+    //printf("dgeev\n");+    dgeev_  (&jobvl,&jobvr,+             &n,B,&n,+             sp, sp+n,+             up,&n,+             vp,&n,+             work, &lwork,+             &res);+    CHECK(res,res);+    free(work);+    free(B);+    OK+}+++//////////////////// symmetric real eigensystem ////////////+++int eig_l_S(KDMAT(a),DVEC(s),DMAT(v)) {+    integer n = ar;+    REQUIRES(n>=2 && ac == n && sn==n && (vr==1 || (vr==n && vc==n)),BAD_SIZE);+    DEBUGMSG("eig_l_S");+    memcpy(vp,ap,n*n*sizeof(double));+    integer lwork = -1;+    char jobz = vr==1?'N':'V';+    char uplo = 'U';+    integer res;+    // ask for optimal lwork+    double ans;+    //printf("ask dsyev\n");+    dsyev_  (&jobz,&uplo,+             &n,vp,&n,+             sp,+             &ans, &lwork,+             &res);+    lwork = ceil(ans);+    //printf("ans = %d\n",lwork);+    double * work = (double*)malloc(lwork*sizeof(double));+    CHECK(!work,MEM);+    dsyev_  (&jobz,&uplo,+             &n,vp,&n,+             sp,+             work, &lwork,+             &res);+    CHECK(res,res);+    free(work);+    OK+}++//////////////////// hermitian complex eigensystem ////////////++int eig_l_H(KCMAT(a),DVEC(s),CMAT(v)) {+    integer n = ar;+    REQUIRES(n>=2 && ac==n && sn==n && (vr==1 || (vr==n && vc==n)),BAD_SIZE);+    DEBUGMSG("eig_l_H");+    memcpy(vp,ap,2*n*n*sizeof(double));+    double *rwork = (double*) malloc((3*n-2)*sizeof(double));+    CHECK(!rwork,MEM);+    integer lwork = -1;+    char jobz = vr==1?'N':'V';+    char uplo = 'U';+    integer res;+    // ask for optimal lwork+    doublecomplex ans;+    //printf("ask zheev\n");+    zheev_  (&jobz,&uplo,+             &n,(doublecomplex*)vp,&n,+             sp,+             &ans, &lwork,+             rwork,+             &res);+    lwork = ceil(ans.r);+    //printf("ans = %d\n",lwork);+    doublecomplex * work = (doublecomplex*)malloc(lwork*2*sizeof(double));+    CHECK(!work,MEM);+    zheev_  (&jobz,&uplo,+             &n,(doublecomplex*)vp,&n,+             sp,+             work, &lwork,+             rwork,+             &res);+    CHECK(res,res);+    free(work);+    free(rwork);+    OK+}++//////////////////// general real linear system ////////////++int linearSolveR_l(KDMAT(a),KDMAT(b),DMAT(x)) {+    integer n = ar;+    integer nhrs = bc;+    REQUIRES(n>=1 && ar==ac && ar==br,BAD_SIZE);+    DEBUGMSG("linearSolveR_l");+    double*AC = (double*)malloc(n*n*sizeof(double));+    memcpy(AC,ap,n*n*sizeof(double));+    memcpy(xp,bp,n*nhrs*sizeof(double));+    integer * ipiv = (integer*)malloc(n*sizeof(integer));+    integer res;+    dgesv_  (&n,&nhrs,+             AC, &n,+             ipiv,+             xp, &n,+             &res);+    if(res>0) {+        return SINGULAR;+    }+    CHECK(res,res);+    free(ipiv);+    free(AC);+    OK+}++//////////////////// general complex linear system ////////////++int linearSolveC_l(KCMAT(a),KCMAT(b),CMAT(x)) {+    integer n = ar;+    integer nhrs = bc;+    REQUIRES(n>=1 && ar==ac && ar==br,BAD_SIZE);+    DEBUGMSG("linearSolveC_l");+    double*AC = (double*)malloc(2*n*n*sizeof(double));+    memcpy(AC,ap,2*n*n*sizeof(double));+    memcpy(xp,bp,2*n*nhrs*sizeof(double));+    integer * ipiv = (integer*)malloc(n*sizeof(integer));+    integer res;+    zgesv_  (&n,&nhrs,+             (doublecomplex*)AC, &n,+             ipiv,+             (doublecomplex*)xp, &n,+             &res);+    if(res>0) {+        return SINGULAR;+    }+    CHECK(res,res);+    free(ipiv);+    free(AC);+    OK+}++//////////////////// least squares real linear system ////////////++int linearSolveLSR_l(KDMAT(a),KDMAT(b),DMAT(x)) {+    integer m = ar;+    integer n = ac;+    integer nrhs = bc;+    integer ldb = xr;+    REQUIRES(m>=1 && n>=1 && ar==br && xr==MAX(m,n) && xc == bc, BAD_SIZE);+    DEBUGMSG("linearSolveLSR_l");+    double*AC = (double*)malloc(m*n*sizeof(double));+    memcpy(AC,ap,m*n*sizeof(double));+    if (m>=n) {+        memcpy(xp,bp,m*nrhs*sizeof(double));+    } else {+        int k;+        for(k = 0; k<nrhs; k++) {+            memcpy(xp+ldb*k,bp+m*k,m*sizeof(double));+        }+    }+    integer res;+    integer lwork = -1;+    double ans;+    dgels_  ("N",&m,&n,&nrhs,+             AC,&m,+             xp,&ldb,+             &ans,&lwork,+             &res);+    lwork = ceil(ans);+    //printf("ans = %d\n",lwork);+    double * work = (double*)malloc(lwork*sizeof(double));+    dgels_  ("N",&m,&n,&nrhs,+             AC,&m,+             xp,&ldb,+             work,&lwork,+             &res);+    if(res>0) {+        return SINGULAR;+    }+    CHECK(res,res);+    free(work);+    free(AC);+    OK+}++//////////////////// least squares complex linear system ////////////++int linearSolveLSC_l(KCMAT(a),KCMAT(b),CMAT(x)) {+    #ifdef _WIN32+    return NOSPRTD;+    #else+    integer m = ar;+    integer n = ac;+    integer nrhs = bc;+    integer ldb = xr;+    REQUIRES(m>=1 && n>=1 && ar==br && xr==MAX(m,n) && xc == bc, BAD_SIZE);+    DEBUGMSG("linearSolveLSC_l");+    double*AC = (double*)malloc(2*m*n*sizeof(double));+    memcpy(AC,ap,2*m*n*sizeof(double));+    memcpy(AC,ap,2*m*n*sizeof(double));+    if (m>=n) {+        memcpy(xp,bp,2*m*nrhs*sizeof(double));+    } else {+        int k;+        for(k = 0; k<nrhs; k++) {+            memcpy(xp+2*ldb*k,bp+2*m*k,m*2*sizeof(double));+        }+    }+    integer res;+    integer lwork = -1;+    doublecomplex ans;+    zgels_  ("N",&m,&n,&nrhs,+             (doublecomplex*)AC,&m,+             (doublecomplex*)xp,&ldb,+             &ans,&lwork,+             &res);+    lwork = ceil(ans.r);+    //printf("ans = %d\n",lwork);+    doublecomplex * work = (doublecomplex*)malloc(lwork*sizeof(doublecomplex));+    zgels_  ("N",&m,&n,&nrhs,+             (doublecomplex*)AC,&m,+             (doublecomplex*)xp,&ldb,+             work,&lwork,+             &res);+    if(res>0) {+        return SINGULAR;+    }+    CHECK(res,res);+    free(work);+    free(AC);+    OK+    #endif+}++//////////////////// least squares real linear system using SVD ////////////++int linearSolveSVDR_l(double rcond,KDMAT(a),KDMAT(b),DMAT(x)) {+    integer m = ar;+    integer n = ac;+    integer nrhs = bc;+    integer ldb = xr;+    REQUIRES(m>=1 && n>=1 && ar==br && xr==MAX(m,n) && xc == bc, BAD_SIZE);+    DEBUGMSG("linearSolveSVDR_l");+    double*AC = (double*)malloc(m*n*sizeof(double));+    double*S = (double*)malloc(MIN(m,n)*sizeof(double));+    memcpy(AC,ap,m*n*sizeof(double));+    if (m>=n) {+        memcpy(xp,bp,m*nrhs*sizeof(double));+    } else {+        int k;+        for(k = 0; k<nrhs; k++) {+            memcpy(xp+ldb*k,bp+m*k,m*sizeof(double));+        }+    }+    integer res;+    integer lwork = -1;+    integer rank;+    double ans;+    dgelss_  (&m,&n,&nrhs,+             AC,&m,+             xp,&ldb,+             S,+             &rcond,&rank,+             &ans,&lwork,+             &res);+    lwork = ceil(ans);+    //printf("ans = %d\n",lwork);+    double * work = (double*)malloc(lwork*sizeof(double));+    dgelss_  (&m,&n,&nrhs,+             AC,&m,+             xp,&ldb,+             S,+             &rcond,&rank,+             work,&lwork,+             &res);+    if(res>0) {+        return NOCONVER;+    }+    CHECK(res,res);+    free(work);+    free(S);+    free(AC);+    OK+}++//////////////////// least squares complex linear system using SVD ////////////++// not in clapack.h++int zgelss_(integer *m, integer *n, integer *nhrs,+    doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublereal *s,+    doublereal *rcond, integer* rank,+    doublecomplex *work, integer* lwork, doublereal* rwork,+    integer *info);++int linearSolveSVDC_l(double rcond, KCMAT(a),KCMAT(b),CMAT(x)) {+    #ifdef _WIN32+    return NOSPRTD;+    #else+    integer m = ar;+    integer n = ac;+    integer nrhs = bc;+    integer ldb = xr;+    REQUIRES(m>=1 && n>=1 && ar==br && xr==MAX(m,n) && xc == bc, BAD_SIZE);+    DEBUGMSG("linearSolveSVDC_l");+    double*AC = (double*)malloc(2*m*n*sizeof(double));+    double*S = (double*)malloc(MIN(m,n)*sizeof(double));+    double*RWORK = (double*)malloc(5*MIN(m,n)*sizeof(double));+    memcpy(AC,ap,2*m*n*sizeof(double));+    if (m>=n) {+        memcpy(xp,bp,2*m*nrhs*sizeof(double));+    } else {+        int k;+        for(k = 0; k<nrhs; k++) {+            memcpy(xp+2*ldb*k,bp+2*m*k,m*2*sizeof(double));+        }+    }+    integer res;+    integer lwork = -1;+    integer rank;+    doublecomplex ans;+    zgelss_  (&m,&n,&nrhs,+             (doublecomplex*)AC,&m,+             (doublecomplex*)xp,&ldb,+             S,+             &rcond,&rank,+             &ans,&lwork,+             RWORK,+             &res);+    lwork = ceil(ans.r);+    //printf("ans = %d\n",lwork);+    doublecomplex * work = (doublecomplex*)malloc(lwork*sizeof(doublecomplex));+    zgelss_  (&m,&n,&nrhs,+             (doublecomplex*)AC,&m,+             (doublecomplex*)xp,&ldb,+             S,+             &rcond,&rank,+             work,&lwork,+             RWORK,+             &res);+    if(res>0) {+        return NOCONVER;+    }+    CHECK(res,res);+    free(work);+    free(RWORK);+    free(S);+    free(AC);+    OK+    #endif+}++//////////////////// Cholesky factorization /////////////////////////++int chol_l_H(KCMAT(a),CMAT(l)) {+    integer n = ar;+    REQUIRES(n>=1 && ac == n && lr==n && lc==n,BAD_SIZE);+    DEBUGMSG("chol_l_H");+    memcpy(lp,ap,n*n*sizeof(doublecomplex));+    char uplo = 'U';+    integer res;+    zpotrf_ (&uplo,&n,(doublecomplex*)lp,&n,&res);+    CHECK(res>0,NODEFPOS);+    CHECK(res,res);+    doublecomplex zero = {0.,0.};+    int r,c;+    for (r=0; r<lr-1; r++) {+        for(c=r+1; c<lc; c++) {+            ((doublecomplex*)lp)[r*lc+c] = zero;+        }+    }+    OK+}++int chol_l_S(KDMAT(a),DMAT(l)) {+    integer n = ar;+    REQUIRES(n>=1 && ac == n && lr==n && lc==n,BAD_SIZE);+    DEBUGMSG("chol_l_S");+    memcpy(lp,ap,n*n*sizeof(double));+    char uplo = 'U';+    integer res;+    dpotrf_ (&uplo,&n,lp,&n,&res);+    CHECK(res>0,NODEFPOS);+    CHECK(res,res);+    int r,c;+    for (r=0; r<lr-1; r++) {+        for(c=r+1; c<lc; c++) {+            lp[r*lc+c] = 0.;+        }+    }+    OK+}++//////////////////// QR factorization /////////////////////////++int qr_l_R(KDMAT(a), DVEC(tau), DMAT(r)) {+    integer m = ar;+    integer n = ac;+    integer mn = MIN(m,n);+    REQUIRES(m>=1 && n >=1 && rr== m && rc == n && taun == mn, BAD_SIZE);+    DEBUGMSG("qr_l_R");+    double *WORK = (double*)malloc(n*sizeof(double));+    CHECK(!WORK,MEM);+    memcpy(rp,ap,m*n*sizeof(double));+    integer res;+    dgeqr2_ (&m,&n,rp,&m,taup,WORK,&res);+    CHECK(res,res);+    free(WORK);+    OK+}++int qr_l_C(KCMAT(a), CVEC(tau), CMAT(r)) {+    integer m = ar;+    integer n = ac;+    integer mn = MIN(m,n);+    REQUIRES(m>=1 && n >=1 && rr== m && rc == n && taun == mn, BAD_SIZE);+    DEBUGMSG("qr_l_C");+    doublecomplex *WORK = (doublecomplex*)malloc(n*sizeof(doublecomplex));+    CHECK(!WORK,MEM);+    memcpy(rp,ap,m*n*sizeof(doublecomplex));+    integer res;+    zgeqr2_ (&m,&n,(doublecomplex*)rp,&m,(doublecomplex*)taup,WORK,&res);+    CHECK(res,res);+    free(WORK);+    OK+}++//////////////////// Hessenberg factorization /////////////////////////++int hess_l_R(KDMAT(a), DVEC(tau), DMAT(r)) {+    integer m = ar;+    integer n = ac;+    integer mn = MIN(m,n);+    REQUIRES(m>=1 && n == m && rr== m && rc == n && taun == mn-1, BAD_SIZE);+    DEBUGMSG("hess_l_R");+    integer lwork = 5*n; // fixme+    double *WORK = (double*)malloc(lwork*sizeof(double));+    CHECK(!WORK,MEM);+    memcpy(rp,ap,m*n*sizeof(double));+    integer res;+    integer one = 1;+    dgehrd_ (&n,&one,&n,rp,&n,taup,WORK,&lwork,&res);+    CHECK(res,res);+    free(WORK);+    OK+}++int hess_l_C(KCMAT(a), CVEC(tau), CMAT(r)) {+    integer m = ar;+    integer n = ac;+    integer mn = MIN(m,n);+    REQUIRES(m>=1 && n == m && rr== m && rc == n && taun == mn-1, BAD_SIZE);+    DEBUGMSG("hess_l_C");+    integer lwork = 5*n; // fixme+    doublecomplex *WORK = (doublecomplex*)malloc(lwork*sizeof(doublecomplex));+    CHECK(!WORK,MEM);+    memcpy(rp,ap,m*n*sizeof(doublecomplex));+    integer res;+    integer one = 1;+    zgehrd_ (&n,&one,&n,(doublecomplex*)rp,&n,(doublecomplex*)taup,WORK,&lwork,&res);+    CHECK(res,res);+    free(WORK);+    OK+}++//////////////////// Schur factorization /////////////////////////++int schur_l_R(KDMAT(a), DMAT(u), DMAT(s)) {+    integer m = ar;+    integer n = ac;+    REQUIRES(m>=1 && n==m && ur==n && uc==n && sr==n && sc==n, BAD_SIZE);+    DEBUGMSG("schur_l_R");+    int k;+    //printf("---------------------------\n");+    //printf("%p: ",ap); for(k=0;k<n*n;k++) printf("%f ",ap[k]); printf("\n");+    //printf("%p: ",up); for(k=0;k<n*n;k++) printf("%f ",up[k]); printf("\n");+    //printf("%p: ",sp); for(k=0;k<n*n;k++) printf("%f ",sp[k]); printf("\n");+    memcpy(sp,ap,n*n*sizeof(double));+    integer lwork = 6*n; // fixme+    double *WORK = (double*)malloc(lwork*sizeof(double));+    double *WR = (double*)malloc(n*sizeof(double));+    double *WI = (double*)malloc(n*sizeof(double));+    // WR and WI not really required in this call+    logical *BWORK = (logical*)malloc(n*sizeof(logical));+    integer res;+    integer sdim;+    dgees_ ("V","N",NULL,&n,sp,&n,&sdim,WR,WI,up,&n,WORK,&lwork,BWORK,&res);+    //printf("%p: ",ap); for(k=0;k<n*n;k++) printf("%f ",ap[k]); printf("\n");+    //printf("%p: ",up); for(k=0;k<n*n;k++) printf("%f ",up[k]); printf("\n");+    //printf("%p: ",sp); for(k=0;k<n*n;k++) printf("%f ",sp[k]); printf("\n");+    if(res>0) {+        return NOCONVER;+    }+    CHECK(res,res);+    free(WR);+    free(WI);+    free(BWORK);+    free(WORK);+    OK+}++int schur_l_C(KCMAT(a), CMAT(u), CMAT(s)) {+    #ifdef _WIN32+    return NOSPRTD;+    #else+    integer m = ar;+    integer n = ac;+    REQUIRES(m>=1 && n==m && ur==n && uc==n && sr==n && sc==n, BAD_SIZE);+    DEBUGMSG("schur_l_C");+    memcpy(sp,ap,n*n*sizeof(doublecomplex));+    integer lwork = 6*n; // fixme+    doublecomplex *WORK = (doublecomplex*)malloc(lwork*sizeof(doublecomplex));+    doublecomplex *W = (doublecomplex*)malloc(n*sizeof(doublecomplex));+    // W not really required in this call+    logical *BWORK = (logical*)malloc(n*sizeof(logical));+    double *RWORK = (double*)malloc(n*sizeof(double));+    integer res;+    integer sdim;+    zgees_ ("V","N",NULL,&n,(doublecomplex*)sp,&n,&sdim,W,+                            (doublecomplex*)up,&n,+                            WORK,&lwork,RWORK,BWORK,&res);+    if(res>0) {+        return NOCONVER;+    }+    CHECK(res,res);+    free(W);+    free(BWORK);+    free(WORK);+    OK+    #endif+}
+ lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.h view
@@ -0,0 +1,54 @@+#include "f2c.h"+#include "clapack.h"++#define DVEC(A) int A##n, double*A##p+#define CVEC(A) int A##n, double*A##p+#define DMAT(A) int A##r, int A##c, double* A##p+#define CMAT(A) int A##r, int A##c, double* A##p++// const pointer versions for the parameters +#define KDVEC(A) int A##n, const double*A##p+#define KCVEC(A) int A##n, const double*A##p+#define KDMAT(A) int A##r, int A##c, const double* A##p+#define KCMAT(A) int A##r, int A##c, const double* A##p ++int svd_l_R(KDMAT(x),DMAT(u),DVEC(s),DMAT(v));+int svd_l_Rdd(KDMAT(x),DMAT(u),DVEC(s),DMAT(v));++int svd_l_C(KCMAT(a),CMAT(u),DVEC(s),CMAT(v));++int eig_l_C(KCMAT(a),CMAT(u),CVEC(s),CMAT(v));++int eig_l_R(KDMAT(a),DMAT(u),CVEC(s),DMAT(v));++int eig_l_S(KDMAT(a),DVEC(s),DMAT(v));++int eig_l_H(KCMAT(a),DVEC(s),CMAT(v));++int linearSolveR_l(KDMAT(a),KDMAT(b),DMAT(x));++int linearSolveC_l(KCMAT(a),KCMAT(b),CMAT(x));++int linearSolveLSR_l(KDMAT(a),KDMAT(b),DMAT(x));++int linearSolveLSC_l(KCMAT(a),KCMAT(b),CMAT(x));++int linearSolveSVDR_l(double,KDMAT(a),KDMAT(b),DMAT(x));++int linearSolveSVDC_l(double,KCMAT(a),KCMAT(b),CMAT(x));++int chol_l_H(KCMAT(a),CMAT(r));++int chol_l_S(KDMAT(a),DMAT(r));++int qr_l_R(KDMAT(a), DVEC(tau), DMAT(r));++int qr_l_C(KCMAT(a), CVEC(tau), CMAT(r));++int hess_l_R(KDMAT(a), DVEC(tau), DMAT(r));++int hess_l_C(KCMAT(a), CVEC(tau), CMAT(r));++int schur_l_R(KDMAT(a), DMAT(u), DMAT(s));++int schur_l_C(KCMAT(a), CMAT(u), CMAT(s));
+ lib/Numeric/LinearAlgebra/Linear.hs view
@@ -0,0 +1,131 @@+{-# OPTIONS_GHC -fglasgow-exts #-}+-----------------------------------------------------------------------------+{- |+Module      :  Numeric.LinearAlgebra.Linear+Copyright   :  (c) Alberto Ruiz 2006-7+License     :  GPL-style++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Basic optimized operations on vectors and matrices.++-}+-----------------------------------------------------------------------------++module Numeric.LinearAlgebra.Linear (+    Linear(..),+    multiply, dot, outer, kronecker+) where+++import Data.Packed.Internal(multiply,partit)+import Data.Packed+import Numeric.GSL.Vector+import Complex++-- | A generic interface for vectors and matrices to a few element-by-element functions in Numeric.GSL.Vector.+class (Container c e) => Linear c e where+    scale       :: e -> c e -> c e+    addConstant :: e -> c e -> c e+    add         :: c e -> c e -> c e+    sub         :: c e -> c e -> c e+    -- | element by element multiplication+    mul         :: c e -> c e -> c e+    -- | element by element division+    divide      :: c e -> c e -> c e+    -- | scale the element by element reciprocal of the object: @scaleRecip 2 (fromList [5,i]) == 2 |> [0.4 :+ 0.0,0.0 :+ (-2.0)]@+    scaleRecip  :: e -> c e -> c e+    equal       :: c e -> c e -> Bool+--  numequal    :: Double -> c e -> c e -> Bool++instance Linear Vector Double where+    scale = vectorMapValR Scale+    scaleRecip = vectorMapValR Recip+    addConstant = vectorMapValR AddConstant+    add = vectorZipR Add+    sub = vectorZipR Sub+    mul = vectorZipR Mul+    divide = vectorZipR Div+    equal u v = dim u == dim v && vectorMax (vectorMapR Abs (sub u v)) == 0.0++instance Linear Vector (Complex Double) where+    scale = vectorMapValC Scale+    scaleRecip = vectorMapValC Recip+    addConstant = vectorMapValC AddConstant+    add = vectorZipC Add+    sub = vectorZipC Sub+    mul = vectorZipC Mul+    divide = vectorZipC Div+    equal u v = dim u == dim v && vectorMax (liftVector magnitude (sub u v)) == 0.0++instance Linear Matrix Double where+    scale x = liftMatrix (scale x)+    scaleRecip x = liftMatrix (scaleRecip x)+    addConstant x = liftMatrix (addConstant x)+    add = liftMatrix2 add+    sub = liftMatrix2 sub+    mul = liftMatrix2 mul+    divide = liftMatrix2 divide+    equal a b = cols a == cols b && flatten a `equal` flatten b+++instance Linear Matrix (Complex Double) where+    scale x = liftMatrix (scale x)+    scaleRecip x = liftMatrix (scaleRecip x)+    addConstant x = liftMatrix (addConstant x)+    add = liftMatrix2 add+    sub = liftMatrix2 sub+    mul = liftMatrix2 mul+    divide = liftMatrix2 divide+    equal a b = cols a == cols b && flatten a `equal` flatten b++--------------------------------------------------++-- | euclidean inner product+dot :: (Element t) => Vector t -> Vector t -> t+dot u v = multiply r c  @@> (0,0)+    where r = asRow u+          c = asColumn v+++{- | Outer product of two vectors.++@\> 'fromList' [1,2,3] \`outer\` 'fromList' [5,2,3]+(3><3)+ [  5.0, 2.0, 3.0+ , 10.0, 4.0, 6.0+ , 15.0, 6.0, 9.0 ]@+-}+outer :: (Element t) => Vector t -> Vector t -> Matrix t+outer u v = asColumn u `multiply` asRow v++{- | Kronecker product of two matrices.++@m1=(2><3)+ [ 1.0,  2.0, 0.0+ , 0.0, -1.0, 3.0 ]+m2=(4><3)+ [  1.0,  2.0,  3.0+ ,  4.0,  5.0,  6.0+ ,  7.0,  8.0,  9.0+ , 10.0, 11.0, 12.0 ]@++@\> kronecker m1 m2+(8><9)+ [  1.0,  2.0,  3.0,   2.0,   4.0,   6.0,  0.0,  0.0,  0.0+ ,  4.0,  5.0,  6.0,   8.0,  10.0,  12.0,  0.0,  0.0,  0.0+ ,  7.0,  8.0,  9.0,  14.0,  16.0,  18.0,  0.0,  0.0,  0.0+ , 10.0, 11.0, 12.0,  20.0,  22.0,  24.0,  0.0,  0.0,  0.0+ ,  0.0,  0.0,  0.0,  -1.0,  -2.0,  -3.0,  3.0,  6.0,  9.0+ ,  0.0,  0.0,  0.0,  -4.0,  -5.0,  -6.0, 12.0, 15.0, 18.0+ ,  0.0,  0.0,  0.0,  -7.0,  -8.0,  -9.0, 21.0, 24.0, 27.0+ ,  0.0,  0.0,  0.0, -10.0, -11.0, -12.0, 30.0, 33.0, 36.0 ]@+-}+kronecker :: (Element t) => Matrix t -> Matrix t -> Matrix t+kronecker a b = fromBlocks+              . partit (cols a)+              . map (reshape (cols b))+              . toRows+              $ flatten a `outer` flatten b