diff --git a/Data/Eigen/Internal.hsc b/Data/Eigen/Internal.hsc --- a/Data/Eigen/Internal.hsc +++ b/Data/Eigen/Internal.hsc @@ -1,4 +1,13 @@ -{-# LANGUAGE MultiParamTypeClasses, ForeignFunctionInterface, ScopedTypeVariables, FunctionalDependencies, FlexibleInstances, EmptyDataDecls, CPP #-} +{-# OPTIONS_HADDOCK hide #-} + +{-# LANGUAGE CPP #-} +{-# LANGUAGE EmptyDataDecls #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE ScopedTypeVariables #-} + module Data.Eigen.Internal where import Foreign.Ptr @@ -7,7 +16,10 @@ import Foreign.C.Types import Foreign.C.String import Control.Monad +#if __GLASGOW_HASKELL__ >= 710 +#else import Control.Applicative +#endif import System.IO.Unsafe import Data.Complex import Data.IORef @@ -112,33 +124,33 @@ magicCode :: Code a => a -> CInt magicCode x = code x `xor` 0x45696730 -#let api name, args = "foreign import ccall \"eigen_%s\" c_%s :: CInt -> %s\n%s :: forall b . Code b => %s\n%s = c_%s (code (undefined :: b))", #name, #name, args, #name, args, #name, #name +#let api1 name, args = "foreign import ccall \"eigen_%s\" c_%s :: CInt -> %s\n%s :: forall b . Code b => %s\n%s = c_%s (code (undefined :: b))", #name, #name, args, #name, args, #name, #name -#api random, "Ptr b -> CInt -> CInt -> IO CString" -#api identity, "Ptr b -> CInt -> CInt -> IO CString" -#api add, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api sub, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api mul, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api diagonal, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api transpose, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api inverse, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api adjoint, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api conjugate, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api normalize, "Ptr b -> CInt -> CInt -> IO CString" -#api sum, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api prod, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api mean, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api norm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api trace, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api squaredNorm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api blueNorm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api hypotNorm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api determinant, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" -#api rank, "CInt -> Ptr CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api image, "CInt -> Ptr (Ptr b) -> Ptr CInt -> Ptr CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api kernel, "CInt -> Ptr (Ptr b) -> Ptr CInt -> Ptr CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api solve, "CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" -#api relativeError, "Ptr b -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 random, "Ptr b -> CInt -> CInt -> IO CString" +#api1 identity, "Ptr b -> CInt -> CInt -> IO CString" +#api1 add, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 sub, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 mul, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 diagonal, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 transpose, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 inverse, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 adjoint, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 conjugate, "Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 normalize, "Ptr b -> CInt -> CInt -> IO CString" +#api1 sum, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 prod, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 mean, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 norm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 trace, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 squaredNorm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 blueNorm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 hypotNorm, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 determinant, "Ptr b -> Ptr b -> CInt -> CInt -> IO CString" +#api1 rank, "CInt -> Ptr CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 image, "CInt -> Ptr (Ptr b) -> Ptr CInt -> Ptr CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 kernel, "CInt -> Ptr (Ptr b) -> Ptr CInt -> Ptr CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 solve, "CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" +#api1 relativeError, "Ptr b -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString" #let api2 name, args = "foreign import ccall \"eigen_%s\" c_%s :: CInt -> %s\n%s :: forall a b . Code b => %s\n%s = c_%s (code (undefined :: b))", #name, #name, args, #name, args, #name, #name @@ -170,7 +182,7 @@ #api2 sparse_fromMatrix, "Ptr b -> CInt -> CInt -> Ptr (CSparseMatrixPtr a b) -> IO CString" #api2 sparse_toMatrix, "CSparseMatrixPtr a b -> Ptr b -> CInt -> CInt -> IO CString" -#let api3 name, args = "foreign import ccall \"eigen_%s\" c_%s :: CInt -> CInt -> %s\n%s :: forall s a b . (Enum s, Code b) => s -> %s\n%s s = c_%s (code (undefined :: b)) (cast (fromEnum s))", #name, #name, args, #name, args, #name, #name +#let api3 name, args = "foreign import ccall \"eigen_%s\" c_%s :: CInt -> CInt -> %s\n%s :: forall s a b . (Code s, Code b) => s -> %s\n%s s = c_%s (code (undefined :: b)) (code s)", #name, #name, args, #name, args, #name, #name #api3 sparse_la_newSolver, "Ptr (CSolverPtr a b) -> IO CString" #api3 sparse_la_freeSolver, "CSolverPtr a b -> IO CString" @@ -186,7 +198,20 @@ #api3 sparse_la_iterations, "CSolverPtr a b -> Ptr CInt -> IO CString" #api3 sparse_la_solve, "CSolverPtr a b -> CSparseMatrixPtr a b -> Ptr (CSparseMatrixPtr a b) -> IO CString" -- #api3 sparse_la_solveWithGuess, "CSolverPtr a b -> CSparseMatrixPtr a b -> CSparseMatrixPtr a b -> Ptr (CSparseMatrixPtr a b) -> IO CString" +#api3 sparse_la_matrixQ, "CSolverPtr a b -> Ptr (CSparseMatrixPtr a b) -> IO CString" +#api3 sparse_la_matrixR, "CSolverPtr a b -> Ptr (CSparseMatrixPtr a b) -> IO CString" +#api3 sparse_la_setPivotThreshold, "CSolverPtr a b -> CDouble -> IO CString" +#api3 sparse_la_rank, "CSolverPtr a b -> Ptr CInt -> IO CString" +#api3 sparse_la_matrixL, "CSolverPtr a b -> Ptr (CSparseMatrixPtr a b) -> IO CString" +#api3 sparse_la_matrixU, "CSolverPtr a b -> Ptr (CSparseMatrixPtr a b) -> IO CString" +#api3 sparse_la_setSymmetric, "CSolverPtr a b -> CInt -> IO CString" +#api3 sparse_la_simplicialFactorize,"CSolverPtr a b -> CSparseMatrixPtr a b -> IO CString" +#api3 sparse_la_determinant, "CSolverPtr a b -> Ptr b -> IO CString" +#api3 sparse_la_logAbsDeterminant, "CSolverPtr a b -> Ptr b -> IO CString" +#api3 sparse_la_absDeterminant, "CSolverPtr a b -> Ptr b -> IO CString" +#api3 sparse_la_signDeterminant, "CSolverPtr a b -> Ptr b -> IO CString" + openStream :: BSL.ByteString -> IO (IORef BSL.ByteString) openStream = newIORef @@ -194,7 +219,7 @@ readStream ref size = readIORef ref >>= \a -> let (b,c) = BSL.splitAt (fromIntegral size) a in if BSL.length b /= fromIntegral size - then error "readStream: stream exhausted" + then fail "readStream: stream exhausted" else do writeIORef ref c return . BS.concat . BSL.toChunks $ b diff --git a/Data/Eigen/LA.hs b/Data/Eigen/LA.hs --- a/Data/Eigen/LA.hs +++ b/Data/Eigen/LA.hs @@ -1,4 +1,6 @@ -{-# LANGUAGE RecordWildCards, ForeignFunctionInterface #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE ForeignFunctionInterface #-} +{-# LANGUAGE RecordWildCards #-} {- | @@ -110,7 +112,10 @@ import Foreign.Storable import Foreign.Marshal.Alloc import qualified Foreign.Concurrent as FC +#if __GLASGOW_HASKELL__ >= 710 +#else import Control.Applicative +#endif import Data.Eigen.Matrix import qualified Data.Eigen.Internal as I import qualified Data.Eigen.Matrix.Mutable as M diff --git a/Data/Eigen/Matrix.hs b/Data/Eigen/Matrix.hs --- a/Data/Eigen/Matrix.hs +++ b/Data/Eigen/Matrix.hs @@ -1,4 +1,11 @@ -{-# LANGUAGE RecordWildCards, MultiParamTypeClasses, Rank2Types, ScopedTypeVariables, FunctionalDependencies, GADTs #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE Rank2Types #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE ScopedTypeVariables #-} + module Data.Eigen.Matrix ( -- * Matrix type -- | Matrix aliases follows Eigen naming convention @@ -78,8 +85,10 @@ normalize, modify, convert, - upperTriangle, + TriangularMode(..), + triangularView, lowerTriangle, + upperTriangle, -- * Matrix serialization encode, decode, @@ -107,7 +116,10 @@ import Control.Monad import Control.Monad.ST import Control.Monad.Primitive +#if __GLASGOW_HASKELL__ >= 710 +#else import Control.Applicative hiding (empty) +#endif import qualified Data.Vector.Storable as VS import qualified Data.Vector.Storable.Mutable as VSM import qualified Data.Eigen.Internal as I @@ -136,7 +148,7 @@ "\n", L.intercalate "\n" $ P.map (L.intercalate "\t" . P.map show) $ toList m, "\n"] --- | Shortcuts for basic matrix math +-- | Basic matrix math exposed through Num instance: `(*)`, `(+)`, `(-)`, `fromInteger`, `signum`, `abs`, `negate` instance I.Elem a b => Num (Matrix a b) where (*) = mul (+) = add @@ -147,26 +159,32 @@ negate = map negate -- | Empty 0x0 matrix +{-# INLINE empty #-} empty :: I.Elem a b => Matrix a b empty = Matrix 0 0 VS.empty -- | Is matrix empty? +{-# INLINE null #-} null :: I.Elem a b => Matrix a b -> Bool null (Matrix rows cols _) = rows == 0 && cols == 0 -- | Is matrix square? +{-# INLINE square #-} square :: I.Elem a b => Matrix a b -> Bool square (Matrix rows cols _) = rows == cols -- | Matrix where all coeffs are filled with given value +{-# INLINE constant #-} constant :: I.Elem a b => Int -> Int -> a -> Matrix a b constant rows cols val = Matrix rows cols $ VS.replicate (rows * cols) (I.cast val) -- | Matrix where all coeff are 0 +{-# INLINE zero #-} zero :: I.Elem a b => Int -> Int -> Matrix a b zero rows cols = constant rows cols 0 -- | Matrix where all coeff are 1 +{-# INLINE ones #-} ones :: I.Elem a b => Int -> Int -> Matrix a b ones rows cols = constant rows cols 1 @@ -185,25 +203,27 @@ unsafeFreeze m -- | Number of rows for the matrix +{-# INLINE rows #-} rows :: I.Elem a b => Matrix a b -> Int rows (Matrix rows _ _) = rows -- | Number of columns for the matrix +{-# INLINE cols #-} cols :: I.Elem a b => Matrix a b -> Int cols (Matrix _ cols _) = cols -vals :: I.Elem a b => Matrix a b -> VS.Vector b -vals (Matrix _ _ vals) = vals - -- | Mtrix size as (rows, cols) pair +{-# INLINE dims #-} dims :: I.Elem a b => Matrix a b -> (Int, Int) dims (Matrix rows cols _) = (rows, cols) -- | Matrix coefficient at specific row and col +{-# INLINE (!) #-} (!) :: I.Elem a b => Matrix a b -> (Int, Int) -> a (!) m (row,col) = coeff row col m -- | Matrix coefficient at specific row and col +{-# INLINE coeff #-} coeff :: I.Elem a b => Int -> Int -> Matrix a b -> a coeff row col m@(Matrix rows cols _) | not (valid m) = error "matrix is not valid" @@ -212,14 +232,17 @@ | otherwise = unsafeCoeff row col m -- | Unsafe version of coeff function. No bounds check performed so SEGFAULT possible +{-# INLINE unsafeCoeff #-} unsafeCoeff :: I.Elem a b => Int -> Int -> Matrix a b -> a unsafeCoeff row col (Matrix rows _ vals) = I.cast $ VS.unsafeIndex vals $ col * rows + row -- | List of coefficients for the given col +{-# INLINE col #-} col :: I.Elem a b => Int -> Matrix a b -> [a] col c m@(Matrix rows _ _) = [coeff r c m | r <- [0..pred rows]] -- | List of coefficients for the given row +{-# INLINE row #-} row :: I.Elem a b => Int -> Matrix a b -> [a] row r m@(Matrix _ cols _) = [coeff r c m | c <- [0..pred cols]] @@ -229,31 +252,38 @@ generate blockRows blockCols $ \row col -> coeff (startRow + row) (startCol + col) m --- | Verify matrix dimensions and values memory layout +-- | Verify matrix dimensions and memory layout +{-# INLINE valid #-} valid :: I.Elem a b => Matrix a b -> Bool valid (Matrix rows cols vals) = rows >= 0 && cols >= 0 && VS.length vals == rows * cols -- | The maximum coefficient of the matrix +{-# INLINE maxCoeff #-} maxCoeff :: (I.Elem a b, Ord a) => Matrix a b -> a maxCoeff = fold1' max -- | The minimum coefficient of the matrix +{-# INLINE minCoeff #-} minCoeff :: (I.Elem a b, Ord a) => Matrix a b -> a minCoeff = fold1' min -- | Top @N@ rows of matrix +{-# INLINE topRows #-} topRows :: I.Elem a b => Int -> Matrix a b -> Matrix a b topRows n m@(Matrix _ cols _) = block 0 0 n cols m -- | Bottom @N@ rows of matrix +{-# INLINE bottomRows #-} bottomRows :: I.Elem a b => Int -> Matrix a b -> Matrix a b bottomRows n m@(Matrix rows cols _) = block (rows - n) 0 n cols m -- | Left @N@ columns of matrix +{-# INLINE leftCols #-} leftCols :: I.Elem a b => Int -> Matrix a b -> Matrix a b leftCols n m@(Matrix rows _ _) = block 0 0 rows n m -- | Right @N@ columns of matrix +{-# INLINE rightCols #-} rightCols :: I.Elem a b => Int -> Matrix a b -> Matrix a b rightCols n m@(Matrix rows cols _) = block 0 (cols - n) rows n m @@ -271,11 +301,13 @@ -- | Convert matrix to a list of rows toList :: I.Elem a b => Matrix a b -> [[a]] -toList (Matrix rows cols vals) = [[I.cast $ vals VS.! (col * rows + row) | col <- [0..pred cols]] | row <- [0..pred rows]] +toList m@(Matrix rows cols vals) + | not (valid m) = error "matrix is not valid" + | otherwise = [[I.cast $ vals `VS.unsafeIndex` (col * rows + row) | col <- [0..pred cols]] | row <- [0..pred rows]] -- | [generate rows cols (λ row col -> val)] -- --- Create matrix using generator function @f row col val@ +-- Create matrix using generator function @λ row col -> val@ -- generate :: I.Elem a b => Int -> Int -> (Int -> Int -> a) -> Matrix a b generate rows cols f = Matrix rows cols $ VS.create $ do @@ -295,7 +327,7 @@ -- | The mean of all coefficients of the matrix mean :: I.Elem a b => Matrix a b -> a -mean = _prop I.prod +mean = _prop I.mean -- | The trace of a matrix is the sum of the diagonal coefficients and can also be computed as sum (diagonal m) trace :: I.Elem a b => Matrix a b -> a @@ -303,15 +335,15 @@ -- | Applied to a predicate and a matrix, all determines if all elements of the matrix satisfies the predicate all :: I.Elem a b => (a -> Bool) -> Matrix a b -> Bool -all f = VS.all (f . I.cast) . vals +all f = VS.all (f . I.cast) . _vals -- | Applied to a predicate and a matrix, any determines if any element of the matrix satisfies the predicate any :: I.Elem a b => (a -> Bool) -> Matrix a b -> Bool -any f = VS.any (f . I.cast) . vals +any f = VS.any (f . I.cast) . _vals -- | Returns the number of coefficients in a given matrix that evaluate to true count :: I.Elem a b => (a -> Bool) -> Matrix a b -> Int -count f = VS.foldl' (\n x -> if f (I.cast x) then succ n else n) 0 . vals +count f = VS.foldl' (\n x -> if f (I.cast x) then succ n else n) 0 . _vals {-| For vectors, the l2 norm, and for matrices the Frobenius norm. In both cases, it consists in the square root of the sum of the square of all the matrix entries. @@ -399,14 +431,37 @@ imap :: I.Elem a b => (Int -> Int -> a -> a) -> Matrix a b -> Matrix a b imap f (Matrix rows cols vals) = Matrix rows cols (VS.imap (\n -> let (c, r) = divMod n rows in I.cast . f r c . I.cast) vals) --- | Upper trinagle of the matrix -upperTriangle :: I.Elem a b => Matrix a b -> Matrix a b -upperTriangle = imap (\row col val -> if row <= col then val else 0) +data TriangularMode + -- | View matrix as a lower triangular matrix. + = Lower + -- | View matrix as an upper triangular matrix. + | Upper + -- | View matrix as a lower triangular matrix with zeros on the diagonal. + | StrictlyLower + -- | View matrix as an upper triangular matrix with zeros on the diagonal. + | StrictlyUpper + -- | View matrix as a lower triangular matrix with ones on the diagonal. + | UnitLower + -- | View matrix as an upper triangular matrix with ones on the diagonal. + | UnitUpper deriving (Eq, Enum, Show, Read) --- | Lower trinagle of the matrix +-- | Triangular view extracted from the current matrix +triangularView :: I.Elem a b => TriangularMode -> Matrix a b -> Matrix a b +triangularView Lower = imap $ \row col val -> case compare row col of { LT -> 0; _ -> val } +triangularView Upper = imap $ \row col val -> case compare row col of { GT -> 0; _ -> val } +triangularView StrictlyLower = imap $ \row col val -> case compare row col of { GT -> val; _ -> 0 } +triangularView StrictlyUpper = imap $ \row col val -> case compare row col of { LT -> val; _ -> 0 } +triangularView UnitLower = imap $ \row col val -> case compare row col of { GT -> val; LT -> 0; EQ -> 1 } +triangularView UnitUpper = imap $ \row col val -> case compare row col of { LT -> val; GT -> 0; EQ -> 1 } + +-- | Lower trinagle of the matrix. Shortcut for @triangularView Lower@ lowerTriangle :: I.Elem a b => Matrix a b -> Matrix a b -lowerTriangle = imap (\row col val -> if row >= col then val else 0) +lowerTriangle = triangularView Lower +-- | Upper trinagle of the matrix. Shortcut for @triangularView Upper@ +upperTriangle :: I.Elem a b => Matrix a b -> Matrix a b +upperTriangle = triangularView Upper + -- | Filter elements in the matrix. Filtered elements will be replaced by 0 filter :: I.Elem a b => (a -> Bool) -> Matrix a b -> Matrix a b filter f = map (\x -> if f x then x else 0) @@ -433,11 +488,11 @@ -- | Reduce matrix using user provided function applied to each element. fold1 :: I.Elem a b => (a -> a -> a) -> Matrix a b -> a -fold1 f = foldl1 f . P.map I.cast . VS.toList . vals +fold1 f = foldl1 f . P.map I.cast . VS.toList . _vals -- | Reduce matrix using user provided function applied to each element. This is strict version of 'fold' fold1' :: I.Elem a b => (a -> a -> a) -> Matrix a b -> a -fold1' f = L.foldl1' f . P.map I.cast . VS.toList . vals +fold1' f = L.foldl1' f . P.map I.cast . VS.toList . _vals -- | Diagonal of the matrix diagonal :: I.Elem a b => Matrix a b -> Matrix a b @@ -527,11 +582,13 @@ return (rows, cols, VS.unsafeFromForeignPtr0 (I.plusForeignPtr fp fo) (rows * cols)) +{-# INLINE _prop #-} _prop :: I.Elem a b => (Ptr b -> Ptr b -> CInt -> CInt -> IO CString) -> Matrix a b -> a _prop f m = I.cast $ I.performIO $ alloca $ \p -> do I.call $ unsafeWith m (f p) peek p +{-# INLINE _binop #-} _binop :: I.Elem a b => ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString) -> Matrix a b -> Matrix a b -> Matrix a b _binop f g m1 m2 = I.performIO $ do m0 <- uncurry M.new $ f (dims m1) (dims m2) @@ -544,6 +601,7 @@ vals2 rows2 cols2 unsafeFreeze m0 +{-# INLINE _unop #-} _unop :: I.Elem a b => ((Int,Int) -> (Int,Int)) -> (Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString) -> Matrix a b -> Matrix a b _unop f g m1 = I.performIO $ do m0 <- uncurry M.new $ f (dims m1) @@ -553,3 +611,7 @@ vals0 rows0 cols0 vals1 rows1 cols1 unsafeFreeze m0 + +{-# INLINE _vals #-} +_vals :: I.Elem a b => Matrix a b -> VS.Vector b +_vals (Matrix _ _ vals) = vals diff --git a/Data/Eigen/SparseLA.hs b/Data/Eigen/SparseLA.hs --- a/Data/Eigen/SparseLA.hs +++ b/Data/Eigen/SparseLA.hs @@ -1,15 +1,17 @@ -{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE ForeignFunctionInterface #-} -{-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE FunctionalDependencies #-} -{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} {- | This documentation is based on original Eigen page Eigen currently provides a limited set of built-in MPL2 compatible solvers. -hey are summarized in the following table: +They are summarized in the following table: @ Sparse solver Solver kind Matrix kind Notes @@ -64,65 +66,85 @@ Finally, each solver provides some specific features, such as determinant, access to the factors, controls of the iterations, and so on. -= The Compute Step - -In the `compute` function, the matrix is generally factorized: LLT for self-adjoint matrices, LDLT for general hermitian matrices, -LU for non hermitian matrices and QR for rectangular matrices. These are the results of using direct solvers. -For this class of solvers precisely, the compute step is further subdivided into `analyzePattern` and `factorize`. - -The goal of `analyzePattern` is to reorder the nonzero elements of the matrix, such that the factorization step creates less fill-in. -This step exploits only the structure of the matrix. Hence, the results of this step can be used for other linear systems where the -matrix has the same structure. - -In `factorize`, the factors of the coefficient matrix are computed. This step should be called each time the values of the matrix change. -However, the structural pattern of the matrix should not change between multiple calls. - -For iterative solvers, the `compute` step is used to eventually setup a preconditioner. -Remember that, basically, the goal of the preconditioner is to speedup the convergence of an iterative method by solving a modified linear -system where the coefficient matrix has more clustered eigenvalues. -For real problems, an iterative solver should always be used with a preconditioner. - -= The Solve Step - -The `solve` function computes the solution of the linear systems with one or many right hand sides. - -@ -x <- solve b -@ - -Here, @b@ can be a vector or a matrix where the columns form the different right hand sides. -The `solve` function can be called several times as well, for instance when all the right hand sides are not available at once. - -@ -x1 <- solve b1 --- Get the second right hand side b2 -x2 <- solve b2 --- ... -@ - -For direct methods, the solution are computed at the machine precision. Sometimes, the solution need not be too accurate. -In this case, the iterative methods are more suitable and the desired accuracy can be set before the solve step using `setTolerance`. -} module Data.Eigen.SparseLA ( - SolverInfo(..), + -- * Sparse Solvers + Solver, + DirectSolver, + IterativeSolver, + OrderingMethod(..), + Preconditioner(..), + ConjugateGradient(ConjugateGradient), + BiCGSTAB(BiCGSTAB), + SparseLU(SparseLU), + SparseQR(SparseQR), ComputationInfo(..), SolverT, runSolverT, -- * The Compute step + {- | + In the `compute` function, the matrix is generally factorized: LLT for self-adjoint matrices, LDLT for general hermitian matrices, + LU for non hermitian matrices and QR for rectangular matrices. These are the results of using direct solvers. + For this class of solvers precisely, the compute step is further subdivided into `analyzePattern` and `factorize`. + + The goal of `analyzePattern` is to reorder the nonzero elements of the matrix, such that the factorization step creates less fill-in. + This step exploits only the structure of the matrix. Hence, the results of this step can be used for other linear systems where the + matrix has the same structure. + + In `factorize`, the factors of the coefficient matrix are computed. This step should be called each time the values of the matrix change. + However, the structural pattern of the matrix should not change between multiple calls. + + For iterative solvers, the `compute` step is used to eventually setup a preconditioner. + Remember that, basically, the goal of the preconditioner is to speedup the convergence of an iterative method by solving a modified linear + system where the coefficient matrix has more clustered eigenvalues. + For real problems, an iterative solver should always be used with a preconditioner. + -} analyzePattern, factorize, compute, -- * The Solve step + {- | + The `solve` function computes the solution of the linear systems with one or many right hand sides. + + @ + x <- solve b + @ + + Here, @b@ can be a vector or a matrix where the columns form the different right hand sides. + The `solve` function can be called several times as well, for instance when all the right hand sides are not available at once. + + @ + x1 <- solve b1 + -- Get the second right hand side b2 + x2 <- solve b2 + -- ... + @ + -} solve, + --solveWithGuess, + info, + -- * Iterative Solvers tolerance, setTolerance, maxIterations, setMaxIterations, - --solveWithGuess, - info, Data.Eigen.SparseLA.error, iterations, + -- * SparseQR Solver + matrixR, + matrixQ, + rank, + setPivotThreshold, + -- * SparseLU Solver + simplicialFactorize, + setSymmetric, + matrixL, + matrixU, + determinant, + absDeterminant, + signDeterminant, + logAbsDeterminant, ) where import Prelude as P @@ -134,52 +156,119 @@ import Control.Monad.IO.Class import Control.Monad.Trans.Reader import qualified Foreign.Concurrent as FC +#if __GLASGOW_HASKELL__ >= 710 +#else import Control.Applicative +#endif import qualified Data.Eigen.Internal as I import qualified Data.Eigen.SparseMatrix as SM -data SolverInfo - {- | A conjugate gradient solver for sparse self-adjoint problems. - - This class allows to solve for @A.x = b@ sparse linear problems using a conjugate gradient algorithm. The sparse matrix @A@ must be selfadjoint. +{- | Ordering methods for sparse matrices. They are typically used to reduce the number of elements during the sparse matrix + decomposition (@LLT@, @LU@, @QR@). Precisely, in a preprocessing step, a permutation matrix @P@ is computed using those ordering methods + and applied to the columns of the matrix. Using for instance the sparse Cholesky decomposition, it is expected that the nonzeros + elements in @LLT(A*P)@ will be much smaller than that in @LLT(A)@. +-} +data OrderingMethod + -- | The column approximate minimum degree ordering The matrix should be in column-major and compressed format + = COLAMDOrdering + -- | The natural ordering (identity) + | NaturalOrdering deriving (Show, Read) - The maximal number of iterations and tolerance value can be controlled via the `setMaxIterations` and `setTolerance` methods. - The defaults are the size of the problem for the maximal number of iterations and @epsilon@ for the tolerance +data Preconditioner + {- | A preconditioner based on the digonal entries + + It allows to approximately solve for A.x = b problems assuming A is a diagonal matrix. + In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for: + @ + A.diagonal().asDiagonal() . x = b + @ + This preconditioner is suitable for both selfadjoint and general problems. + The diagonal entries are pre-inverted and stored into a dense vector. + + A variant that has yet to be implemented would attempt to preserve the norm of each column. -} - = ConjugateGradient - {- | A bi conjugate gradient stabilized solver for sparse square problems. + = DiagonalPreconditioner + -- | A naive preconditioner which approximates any matrix as the identity matrix + | IdentityPreconditioner deriving (Show, Read) - This class allows to solve for @A.x = b@ sparse linear problems using a bi conjugate gradient stabilized algorithm. - The vectors @x@ and @b@ can be either dense or sparse. - The maximal number of iterations and tolerance value can be controlled via the `setMaxIterations` and `setTolerance` methods. - The defaults are the size of the problem for the maximal number of iterations and @epsilon@ for the tolerance - -} - | BiCGSTAB - {- | Sparse supernodal LU factorization for general matrices. +class I.Code s => Solver s where +-- | For direct methods, the solution are computed at the machine precision. +class Solver s => DirectSolver s where +-- | Sometimes, the solution need not be too accurate. +-- In this case, the iterative methods are more suitable and the desired accuracy can be set before the solve step using `setTolerance`. +class Solver s => IterativeSolver s where - This class implements the supernodal LU factorization for general matrices. It uses the main techniques from the sequential - . It handles transparently real and complex arithmetics with - single and double precision, depending on the scalar type of your input matrix. The code has been optimized to provide BLAS-3 - operations during supernode-panel updates. It benefits directly from the built-in high-performant Eigen BLAS routines. - Moreover, when the size of a supernode is very small, the BLAS calls are avoided to enable a better optimization from the compiler. - For best performance, you should compile it with NDEBUG flag to avoid the numerous bounds checking on vectors. - -} - | SparseLU - {- | Sparse left-looking rank-revealing QR factorization. +{- | A conjugate gradient solver for sparse self-adjoint problems. - This class implements a left-looking rank-revealing QR decomposition of sparse matrices. When a column has a norm less than a given - tolerance it is implicitly permuted to the end. The QR factorization thus obtained is given by @A*P = Q*R@ where @R@ is upper triangular or trapezoidal. + This class allows to solve for @A.x = b@ sparse linear problems using a conjugate gradient algorithm. The sparse matrix @A@ must be selfadjoint. - @P@ is the column permutation which is the product of the fill-reducing and the rank-revealing permutations. + The maximal number of iterations and tolerance value can be controlled via the `setMaxIterations` and `setTolerance` methods. + The defaults are the size of the problem for the maximal number of iterations and @epsilon@ for the tolerance +-} +data ConjugateGradient = ConjugateGradient Preconditioner deriving (Show, Read) +instance Solver ConjugateGradient +instance IterativeSolver ConjugateGradient +instance I.Code ConjugateGradient where + code (ConjugateGradient DiagonalPreconditioner) = 0 + code (ConjugateGradient IdentityPreconditioner) = 1 - @Q@ is the orthogonal matrix represented as products of Householder reflectors. +{- | A bi conjugate gradient stabilized solver for sparse square problems. - @R@ is the sparse triangular or trapezoidal matrix. The later occurs when @A@ is rank-deficient. - -} - | SparseQR - deriving (Eq, Enum, Show, Read) + This class allows to solve for @A.x = b@ sparse linear problems using a bi conjugate gradient stabilized algorithm. + The vectors @x@ and @b@ can be either dense or sparse. + The maximal number of iterations and tolerance value can be controlled via the `setMaxIterations` and `setTolerance` methods. + The defaults are the size of the problem for the maximal number of iterations and @epsilon@ for the tolerance +-} +data BiCGSTAB = BiCGSTAB Preconditioner deriving (Show, Read) +instance Solver BiCGSTAB +instance IterativeSolver BiCGSTAB +instance I.Code BiCGSTAB where + code (BiCGSTAB DiagonalPreconditioner) = 2 + code (BiCGSTAB IdentityPreconditioner) = 3 + +{- | Sparse supernodal LU factorization for general matrices. + + This class implements the supernodal LU factorization for general matrices. It uses the main techniques from the sequential + . It handles transparently real and complex arithmetics with + single and double precision, depending on the scalar type of your input matrix. The code has been optimized to provide BLAS-3 + operations during supernode-panel updates. It benefits directly from the built-in high-performant Eigen BLAS routines. + Moreover, when the size of a supernode is very small, the BLAS calls are avoided to enable a better optimization from the compiler. + For best performance, you should compile it with NDEBUG flag to avoid the numerous bounds checking on vectors. + + An important parameter of this class is the ordering method. It is used to reorder the columns + (and eventually the rows) of the matrix to reduce the number of new elements that are created during + numerical factorization. The cheapest method available is COLAMD. + See \link OrderingMethods_Module the OrderingMethods module \endlink for the list of + built-in and external ordering methods. +-} +data SparseLU = SparseLU OrderingMethod deriving (Show, Read) +instance Solver SparseLU +instance DirectSolver SparseLU +instance I.Code SparseLU where + code (SparseLU NaturalOrdering) = 4 + code (SparseLU COLAMDOrdering) = 5 + +{- | Sparse left-looking rank-revealing QR factorization. + + This class implements a left-looking rank-revealing QR decomposition of sparse matrices. When a column has a norm less than a given + tolerance it is implicitly permuted to the end. The QR factorization thus obtained is given by @A*P = Q*R@ where @R@ is upper triangular or trapezoidal. + + @P@ is the column permutation which is the product of the fill-reducing and the rank-revealing permutations. + + @Q@ is the orthogonal matrix represented as products of Householder reflectors. + + @R@ is the sparse triangular or trapezoidal matrix. The later occurs when @A@ is rank-deficient. +-} +data SparseQR = SparseQR OrderingMethod deriving (Show, Read) +instance Solver SparseQR +instance DirectSolver SparseQR +instance I.Code SparseQR where + code (SparseQR NaturalOrdering) = 6 + code (SparseQR COLAMDOrdering) = 7 + + data ComputationInfo -- | Computation was successful. = Success @@ -191,9 +280,9 @@ | InvalidInput deriving (Eq, Enum, Show, Read) -type SolverT a b m = ReaderT (SolverInfo, ForeignPtr (I.CSolver a b)) m +type SolverT s a b m = ReaderT (s, ForeignPtr (I.CSolver a b)) m -runSolverT :: (MonadIO m, I.Elem a b) => SolverInfo -> SolverT a b m c -> m c +runSolverT :: (Solver s, MonadIO m, I.Elem a b) => s -> SolverT s a b m c -> m c runSolverT i f = do fs <- liftIO $ alloca $ \ps -> do I.call $ I.sparse_la_newSolver i ps @@ -202,47 +291,30 @@ runReaderT f (i,fs) -- | Initializes the iterative solver for the sparsity pattern of the matrix @A@ for further solving @Ax=b@ problems. -analyzePattern :: (MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT a b m () +analyzePattern :: (Solver s, MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT s a b m () analyzePattern (SM.SparseMatrix fa) = ask >>= \(i,fs) -> liftIO $ withForeignPtr fs $ \s -> withForeignPtr fa $ \a -> I.call $ I.sparse_la_analyzePattern i s a --- | nitializes the iterative solver with the numerical values of the matrix @A@ for further solving @Ax=b@ problems. -factorize :: (MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT a b m () +-- | Initializes the iterative solver with the numerical values of the matrix @A@ for further solving @Ax=b@ problems. +factorize :: (Solver s, MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT s a b m () factorize (SM.SparseMatrix fa) = ask >>= \(i,fs) -> liftIO $ withForeignPtr fs $ \s -> withForeignPtr fa $ \a -> I.call $ I.sparse_la_factorize i s a -- | Initializes the iterative solver with the matrix @A@ for further solving @Ax=b@ problems. --- +-- -- The `compute` method is equivalent to calling both `analyzePattern` and `factorize`. -compute :: (MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT a b m () +compute :: (Solver s, MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT s a b m () compute (SM.SparseMatrix fa) = ask >>= \(i,fs) -> liftIO $ withForeignPtr fs $ \s -> withForeignPtr fa $ \a -> I.call $ I.sparse_la_compute i s a --- | The tolerance threshold used by the stopping criteria. -tolerance :: (MonadIO m, I.Elem a b) => SolverT a b m Double -tolerance = _get_prop I.sparse_la_tolerance - --- | Sets the tolerance threshold used by the stopping criteria. --- | This value is used as an upper bound to the relative residual error: @|Ax-b|/|b|@. The default value is the machine precision given by epsilon -setTolerance :: (MonadIO m, I.Elem a b) => Double -> SolverT a b m () -setTolerance = _set_prop I.sparse_la_setTolerance - --- | The max number of iterations. It is either the value setted by setMaxIterations or, by default, twice the number of columns of the matrix. -maxIterations :: (MonadIO m, I.Elem a b) => SolverT a b m Int -maxIterations = _get_prop I.sparse_la_maxIterations - --- | Sets the max number of iterations. Default is twice the number of columns of the matrix. -setMaxIterations :: (MonadIO m, I.Elem a b) => Int -> SolverT a b m () -setMaxIterations = _set_prop I.sparse_la_setMaxIterations - -- | An expression of the solution x of @A x = b@ using the current decomposition of @A@. -solve :: (MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT a b m (SM.SparseMatrix a b) +solve :: (Solver s, MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SolverT s a b m (SM.SparseMatrix a b) solve (SM.SparseMatrix fb) = ask >>= \(i,fs) -> liftIO $ withForeignPtr fs $ \s -> withForeignPtr fb $ \b -> @@ -253,7 +325,7 @@ {- -- | The solution @x@ of @A x = b@ using the current decomposition of @A@ and @x0@ as an initial solution. -solveWithGuess :: (MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SM.SparseMatrix a b -> SolverT a b m (SM.SparseMatrix a b) +solveWithGuess :: (MonadIO m, I.Elem a b) => SM.SparseMatrix a b -> SM.SparseMatrix a b -> SolverT s a b m (SM.SparseMatrix a b) solveWithGuess (SM.SparseMatrix fb) (SM.SparseMatrix fx0) = ask >>= \(i,fs) -> liftIO $ withForeignPtr fs $ \s -> withForeignPtr fb $ \b -> @@ -264,23 +336,107 @@ SM.SparseMatrix <$> FC.newForeignPtr x (I.call $ I.sparse_free x) -} -info :: (MonadIO m, I.Elem a b) => SolverT a b m ComputationInfo +-- | Success if the iterations converged, and NoConvergence otherwise. +info :: (Solver s, MonadIO m, I.Elem a b) => SolverT s a b m ComputationInfo info = _get_prop I.sparse_la_info >>= \x -> return (toEnum x) +-- | The tolerance threshold used by the stopping criteria. +tolerance :: (IterativeSolver s, MonadIO m, I.Elem a b) => SolverT s a b m Double +tolerance = _get_prop I.sparse_la_tolerance + +-- | Sets the tolerance threshold used by the stopping criteria. +-- +-- This value is used as an upper bound to the relative residual error: @|Ax-b|/|b|@. The default value is the machine precision given by epsilon +setTolerance :: (IterativeSolver s, MonadIO m, I.Elem a b) => Double -> SolverT s a b m () +setTolerance = _set_prop I.sparse_la_setTolerance + +-- | The max number of iterations. It is either the value setted by setMaxIterations or, by default, twice the number of columns of the matrix. +maxIterations :: (IterativeSolver s, MonadIO m, I.Elem a b) => SolverT s a b m Int +maxIterations = _get_prop I.sparse_la_maxIterations + +-- | Sets the max number of iterations. Default is twice the number of columns of the matrix. +setMaxIterations :: (IterativeSolver s, MonadIO m, I.Elem a b) => Int -> SolverT s a b m () +setMaxIterations = _set_prop I.sparse_la_setMaxIterations + -- | The tolerance error reached during the last solve. It is a close approximation of the true relative residual error @|Ax-b|/|b|@. -error :: (MonadIO m, I.Elem a b) => SolverT a b m Double +error :: (IterativeSolver s, MonadIO m, I.Elem a b) => SolverT s a b m Double error = _get_prop I.sparse_la_error -- | The number of iterations performed during the last solve -iterations :: (MonadIO m, I.Elem a b) => SolverT a b m Int +iterations :: (IterativeSolver s, MonadIO m, I.Elem a b) => SolverT s a b m Int iterations = _get_prop I.sparse_la_iterations -_get_prop :: (I.Cast c d, MonadIO m, Storable c) => (SolverInfo -> I.CSolverPtr a b -> Ptr c -> IO CString) -> SolverT a b m d +-- | Returns the @b@ sparse upper triangular matrix @R@ of the QR factorization. +matrixR :: (MonadIO m, I.Elem a b) => SolverT SparseQR a b m (SM.SparseMatrix a b) +matrixR = _get_matrix I.sparse_la_matrixR + +-- | Returns the matrix @Q@ as products of sparse Householder reflectors. +matrixQ :: (MonadIO m, I.Elem a b) => SolverT SparseQR a b m (SM.SparseMatrix a b) +matrixQ = _get_matrix I.sparse_la_matrixQ + +-- | Sets the threshold that is used to determine linearly dependent columns during the factorization. +-- +-- In practice, if during the factorization the norm of the column that has to be eliminated is below +-- this threshold, then the entire column is treated as zero, and it is moved at the end. +setPivotThreshold :: (MonadIO m, I.Elem a b) => Double -> SolverT SparseQR a b m () +setPivotThreshold = _set_prop I.sparse_la_setPivotThreshold + +-- | Returns the number of non linearly dependent columns as determined by the pivoting threshold. +rank :: (MonadIO m, I.Elem a b) => SolverT SparseQR a b m Int +rank = _get_prop I.sparse_la_rank + +simplicialFactorize :: (MonadIO m, I.Elem a b) => (SM.SparseMatrix a b) -> SolverT SparseLU a b m () +simplicialFactorize (SM.SparseMatrix fa) = ask >>= \(i,fs) -> liftIO $ + withForeignPtr fs $ \s -> + withForeignPtr fa $ \a -> + I.call $ I.sparse_la_simplicialFactorize i s a + +-- | Indicate that the pattern of the input matrix is symmetric +setSymmetric :: (MonadIO m, I.Elem a b) => Bool -> SolverT SparseLU a b m () +setSymmetric = _set_prop I.sparse_la_setSymmetric . fromEnum + +-- | Returns the matrix L +matrixL :: (MonadIO m, I.Elem a b) => SolverT SparseLU a b m (SM.SparseMatrix a b) +matrixL = _get_matrix I.sparse_la_matrixL + +-- | Returns the matrix U +matrixU :: (MonadIO m, I.Elem a b) => SolverT SparseLU a b m (SM.SparseMatrix a b) +matrixU = _get_matrix I.sparse_la_matrixU + +-- | The determinant of the matrix. +determinant :: (MonadIO m, I.Elem a b) => SolverT SparseLU a b m a +determinant = _get_prop I.sparse_la_determinant + +-- | The natural log of the absolute value of the determinant of the matrix of which this is the QR decomposition +-- +-- This method is useful to work around the risk of overflow/underflow that's inherent to the determinant computation. +logAbsDeterminant :: (MonadIO m, I.Elem a b) => SolverT SparseLU a b m a +logAbsDeterminant = _get_prop I.sparse_la_logAbsDeterminant + +-- | The absolute value of the determinant of the matrix of which *this is the QR decomposition. +-- +-- A determinant can be very big or small, so for matrices of large enough dimension, there is a risk of overflow/underflow. +-- One way to work around that is to use `logAbsDeterminant` instead. +absDeterminant :: (MonadIO m, I.Elem a b) => SolverT SparseLU a b m a +absDeterminant = _get_prop I.sparse_la_absDeterminant + +-- | A number representing the sign of the determinant +signDeterminant :: (MonadIO m, I.Elem a b) => SolverT SparseLU a b m a +signDeterminant = _get_prop I.sparse_la_signDeterminant + +_get_prop :: (I.Cast c d, Solver s, MonadIO m, Storable c) => (s -> I.CSolverPtr a b -> Ptr c -> IO CString) -> SolverT s a b m d _get_prop f = ask >>= \(i,fs) -> liftIO $ withForeignPtr fs $ \s -> alloca $ \px -> do I.call $ f i s px I.cast <$> peek px -_set_prop :: (I.Cast c d, MonadIO m, Storable c) => (SolverInfo -> I.CSolverPtr a b -> d -> IO CString) -> c -> SolverT a b m () +_get_matrix :: (Solver s, MonadIO m, I.Elem a b) => (s -> I.CSolverPtr a b -> Ptr (I.CSparseMatrixPtr a b) -> IO CString) -> SolverT s a b m (SM.SparseMatrix a b) +_get_matrix f = ask >>= \(i,fs) -> liftIO $ + withForeignPtr fs $ \s -> alloca $ \px -> do + I.call $ f i s px + x <- peek px + SM.SparseMatrix <$> FC.newForeignPtr x (I.call $ I.sparse_free x) + +_set_prop :: (I.Cast c d, Solver s, MonadIO m, Storable c) => (s -> I.CSolverPtr a b -> d -> IO CString) -> c -> SolverT s a b m () _set_prop f x = ask >>= \(i,fs) -> liftIO $ withForeignPtr fs $ \s -> I.call $ f i s (I.cast x) diff --git a/Data/Eigen/SparseMatrix.hs b/Data/Eigen/SparseMatrix.hs --- a/Data/Eigen/SparseMatrix.hs +++ b/Data/Eigen/SparseMatrix.hs @@ -1,6 +1,7 @@ +{-# LANGUAGE CPP #-} +{-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE FlexibleContexts #-} module Data.Eigen.SparseMatrix ( -- * SparseMatrix type @@ -58,7 +59,10 @@ import Foreign.ForeignPtr import Foreign.Marshal.Alloc import Control.Monad +#if __GLASGOW_HASKELL__ >= 710 +#else import Control.Applicative +#endif import qualified Data.Eigen.Matrix as M import qualified Data.Eigen.Matrix.Mutable as MM import qualified Foreign.Concurrent as FC diff --git a/cbits/eigen-sparse-la.cpp b/cbits/eigen-sparse-la.cpp --- a/cbits/eigen-sparse-la.cpp +++ b/cbits/eigen-sparse-la.cpp @@ -7,10 +7,14 @@ typedef SparseMatrix M2; typedef SparseMatrix M3; -template struct S0 { typedef ConjugateGradient< SparseMatrix > type; }; -template struct S1 { typedef BiCGSTAB< SparseMatrix > type; }; -template struct S2 { typedef SparseLU< SparseMatrix > type; }; -template struct S3 { typedef SparseQR< SparseMatrix , COLAMDOrdering::Index> > type; }; +template struct S0 { typedef ConjugateGradient< SparseMatrix , Lower, DiagonalPreconditioner::Scalar> > type; }; +template struct S1 { typedef ConjugateGradient< SparseMatrix , Lower, IdentityPreconditioner > type; }; +template struct S2 { typedef BiCGSTAB< SparseMatrix , DiagonalPreconditioner::Scalar> > type; }; +template struct S3 { typedef BiCGSTAB< SparseMatrix , IdentityPreconditioner > type; }; +template struct S4 { typedef SparseLU< SparseMatrix , NaturalOrdering > type; }; +template struct S5 { typedef SparseLU< SparseMatrix , COLAMDOrdering > type; }; +template struct S6 { typedef SparseQR< SparseMatrix , NaturalOrdering > type; }; +template struct S7 { typedef SparseQR< SparseMatrix , COLAMDOrdering > type; }; #define API_ALL(name,args,call) \ extern "C" RET eigen_##name args {\ @@ -21,24 +25,40 @@ case 1: return name::type >call;\ case 2: return name::type >call;\ case 3: return name::type >call;\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ }\ case 1: switch(s) {\ case 0: return name::type >call;\ case 1: return name::type >call;\ case 2: return name::type >call;\ case 3: return name::type >call;\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ }\ case 2: switch(s) {\ - case 0: return name::type >call;\ - case 1: return name::type >call;\ - case 2: return name::type >call;\ - case 3: return name::type >call;\ + case 0: return name::type >call;\ + case 1: return name::type >call;\ + case 2: return name::type >call;\ + case 3: return name::type >call;\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ }\ case 3: switch(s) {\ - case 0: return name::type >call;\ - case 1: return name::type >call;\ - case 2: return name::type >call;\ - case 3: return name::type >call;\ + case 0: return name::type >call;\ + case 1: return name::type >call;\ + case 2: return name::type >call;\ + case 3: return name::type >call;\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ }\ }\ GUARD_END\ @@ -51,18 +71,26 @@ case 0: switch(s) {\ case 0: return name::type >call;\ case 1: return name::type >call;\ + case 2: return name::type >call;\ + case 3: return name::type >call;\ }\ case 1: switch(s) {\ - case 0: return name::type >call;\ - case 1: return name::type >call;\ + case 0: return name::type >call;\ + case 1: return name::type >call;\ + case 2: return name::type >call;\ + case 3: return name::type >call;\ }\ case 2: switch(s) {\ case 0: return name::type >call;\ case 1: return name::type >call;\ + case 2: return name::type >call;\ + case 3: return name::type >call;\ }\ case 3: switch(s) {\ case 0: return name::type >call;\ case 1: return name::type >call;\ + case 2: return name::type >call;\ + case 3: return name::type >call;\ }\ }\ return strdup("supported for iterative solver only");\ @@ -167,14 +195,157 @@ // } // API_ALL(sparse_la_solveWithGuess, (int code, int s, void* p, void* b, void* x0, void** x), (p,b,x0,x)); +#define API_SPARSE_LU(name,args,call) \ +extern "C" RET eigen_##name args {\ + GUARD_START\ + switch (code) {\ + case 0: switch(s) {\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + }\ + case 1: switch(s) {\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + }\ + case 2: switch(s) {\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + }\ + case 3: switch(s) {\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + }\ + }\ + return strdup("supported for SparseLU solver only");\ + GUARD_END\ +} +#define API_SPARSE_LU_NO_COMPLEX(name,args,call) \ +extern "C" RET eigen_##name args {\ + GUARD_START\ + switch (code) {\ + case 0: switch(s) {\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + }\ + case 1: switch(s) {\ + case 4: return name::type >call;\ + case 5: return name::type >call;\ + }\ + }\ + return strdup("supported for SparseLU solver and non-complex matrix only");\ + GUARD_END\ +} +#define API_SPARSE_QR(name,args,call) \ +extern "C" RET eigen_##name args {\ + GUARD_START\ + switch (code) {\ + case 0: switch(s) {\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ + }\ + case 1: switch(s) {\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ + }\ + case 2: switch(s) {\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ + }\ + case 3: switch(s) {\ + case 6: return name::type >call;\ + case 7: return name::type >call;\ + }\ + }\ + return strdup("supported for SparseQR solver only");\ + GUARD_END\ +} +template +RET sparse_la_matrixQ(void* p, void** x) { + // *x = new M(((S*)p)->matrixQ()); + // return 0; + return strdup("not implemented yet"); +} +API_SPARSE_QR(sparse_la_matrixQ, (int code, int s, void* p, void** x), (p,x)); +template +RET sparse_la_matrixR(void* p, void** x) { + *x = new M(((S*)p)->matrixR()); + return 0; +} +API_SPARSE_QR(sparse_la_matrixR, (int code, int s, void* p, void** x), (p,x)); +template +RET sparse_la_setPivotThreshold(void* p, double x) { + ((S*)p)->setPivotThreshold(x); + return 0; +} +API_SPARSE_QR(sparse_la_setPivotThreshold, (int code, int s, void* p, double x), (p,x)); +template +RET sparse_la_rank(void* p, double* x) { + *x = ((S*)p)->rank(); + return 0; +} +API_SPARSE_QR(sparse_la_rank, (int code, int s, void* p, double* x), (p,x)); +template +RET sparse_la_simplicialFactorize(void* p, void* a) { + ((S*)p)->simplicialfactorize(*(M*)a); + return 0; +} +API_SPARSE_LU(sparse_la_simplicialFactorize, (int code, int s, void* p, void* a), (p,a)); +template +RET sparse_la_setSymmetric(void* p, int x) { + ((S*)p)->isSymmetric(x); + return 0; +} +API_SPARSE_LU(sparse_la_setSymmetric, (int code, int s, void* p, int x), (p,x)); +template +RET sparse_la_matrixL(void* p, void** x) { + // *x = new M(((S*)p)->matrixL()); + // return 0; + return strdup("not implemented yet"); +} +API_SPARSE_LU(sparse_la_matrixL, (int code, int s, void* p, void** x), (p,x)); +template +RET sparse_la_matrixU(void* p, void** x) { + // *x = new M(((S*)p)->matrixU()); + // return 0; + return strdup("not implemented yet"); +} +API_SPARSE_LU(sparse_la_matrixU, (int code, int s, void* p, void** x), (p,x)); + +template +RET sparse_la_determinant(void* p, void* x) { + *(T*)x = ((S*)p)->determinant(); + return 0; +} +API_SPARSE_LU(sparse_la_determinant, (int code, int s, void* p, void* x), (p,x)); + +template +RET sparse_la_logAbsDeterminant(void* p, void* x) { + *(T*)x = ((S*)p)->logAbsDeterminant(); + return 0; +} +API_SPARSE_LU(sparse_la_logAbsDeterminant, (int code, int s, void* p, void* x), (p,x)); + +template +RET sparse_la_absDeterminant(void* p, void* x) { + *(T*)x = ((S*)p)->absDeterminant(); + return 0; +} +API_SPARSE_LU(sparse_la_absDeterminant, (int code, int s, void* p, void* x), (p,x)); + +template +RET sparse_la_signDeterminant(void* p, void* x) { + *(T*)x = ((S*)p)->signDeterminant(); + return 0; +} +API_SPARSE_LU_NO_COMPLEX(sparse_la_signDeterminant, (int code, int s, void* p, void* x), (p,x)); diff --git a/eigen.cabal b/eigen.cabal --- a/eigen.cabal +++ b/eigen.cabal @@ -1,18 +1,43 @@ name: eigen -version: 2.1.2 +version: 2.1.3 homepage: https://github.com/osidorkin/haskell-eigen -synopsis: Eigen C++ library (linear algebra: matrices, vectors, numerical solvers). -description: This module provides Haskell binding for Eigen C++ library. - Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. - Eigen home page is . +synopsis: Eigen C++ library (linear algebra: matrices, sparse matrices, vectors, numerical solvers). +description: This module provides Haskell binding for . . + Eigen is versatile. + . + * It supports all matrix sizes, from small fixed-size matrices to arbitrarily large dense matrices, and even sparse matrices. + * It supports all standard numeric types, including std::complex, integers, and is easily extensible to custom numeric types. + * It supports various and . + * Its ecosystem of provides many specialized features such as non-linear optimization, matrix functions, a polynomial solver, FFT, and much more. + . + Eigen is fast. + . + * Expression templates allow to intelligently remove temporaries and enable , when that is appropriate. + * is performed for SSE 2/3/4, ARM NEON, and AltiVec instruction sets, with graceful fallback to non-vectorized code. + * Fixed-size matrices are fully optimized: dynamic memory allocation is avoided, and the loops are unrolled when that makes sense. + * For large matrices, special attention is paid to cache-friendliness. + . + Eigen is reliable. + . + * Algorithms are carefully selected for reliability. Reliability trade-offs are and are available. + * Eigen is thoroughly tested through its own (over 500 executables), the standard BLAS test suite, and parts of the LAPACK test suite. + . + Eigen is elegant. + . + * The API is extremely while feeling natural to C++ programmers, thanks to expression templates. + * Implementing an algorithm on top of Eigen feels like just copying pseudocode. + . + Eigen has good compiler support as we run our test suite against many compilers to guarantee reliability and work around any compiler bugs. + Eigen also is standard C++98 and maintains very reasonable compilation times. + . Eigen is licensed under the MPL2, which is a simple weak copyleft license. Common questions about the MPL2 are answered in the official MPL2 FAQ at . . Note that currently, a few features in Eigen rely on third-party code licensed under the LGPL: SimplicialCholesky, AMD ordering, and constrained_cg. Such features are explicitly disabled by compiling Eigen with the EIGEN_MPL2_ONLY preprocessor symbol defined. . Virtually any software may use Eigen. For example, closed-source software may use Eigen without having to disclose its own source code. Many proprietary and closed-source software projects are using Eigen right now, as well as many BSD-licensed projects. . - Some parts of documentation strings are based or replicate original Eigen documentation which is available at . + Documentation at the most extent replicates original . category: Data, Math, Algebra, Statistics, Algorithms, Numeric license: BSD3 license-file: LICENSE @@ -31,166 +56,6 @@ eigen3/.hgeol eigen3/.hgignore eigen3/.hgtags - eigen3/bench/basicbench.cxxlist - eigen3/bench/basicbenchmark.cpp - eigen3/bench/basicbenchmark.h - eigen3/bench/bench_gemm.cpp - eigen3/bench/bench_multi_compilers.sh - eigen3/bench/bench_norm.cpp - eigen3/bench/bench_reverse.cpp - eigen3/bench/bench_sum.cpp - eigen3/bench/bench_unrolling - eigen3/bench/benchBlasGemm.cpp - eigen3/bench/benchCholesky.cpp - eigen3/bench/benchEigenSolver.cpp - eigen3/bench/benchFFT.cpp - eigen3/bench/benchGeometry.cpp - eigen3/bench/benchmark.cpp - eigen3/bench/benchmark_suite - eigen3/bench/benchmarkSlice.cpp - eigen3/bench/benchmarkX.cpp - eigen3/bench/benchmarkXcwise.cpp - eigen3/bench/BenchSparseUtil.h - eigen3/bench/BenchTimer.h - eigen3/bench/BenchUtil.h - eigen3/bench/benchVecAdd.cpp - eigen3/bench/btl/actions/action_aat_product.hh - eigen3/bench/btl/actions/action_ata_product.hh - eigen3/bench/btl/actions/action_atv_product.hh - eigen3/bench/btl/actions/action_axpby.hh - eigen3/bench/btl/actions/action_axpy.hh - eigen3/bench/btl/actions/action_cholesky.hh - eigen3/bench/btl/actions/action_ger.hh - eigen3/bench/btl/actions/action_hessenberg.hh - eigen3/bench/btl/actions/action_lu_decomp.hh - eigen3/bench/btl/actions/action_lu_solve.hh - eigen3/bench/btl/actions/action_matrix_matrix_product.hh - eigen3/bench/btl/actions/action_matrix_matrix_product_bis.hh - eigen3/bench/btl/actions/action_matrix_vector_product.hh - eigen3/bench/btl/actions/action_partial_lu.hh - eigen3/bench/btl/actions/action_rot.hh - eigen3/bench/btl/actions/action_symv.hh - eigen3/bench/btl/actions/action_syr2.hh - eigen3/bench/btl/actions/action_trisolve.hh - eigen3/bench/btl/actions/action_trisolve_matrix.hh - eigen3/bench/btl/actions/action_trmm.hh - eigen3/bench/btl/actions/basic_actions.hh - eigen3/bench/btl/cmake/FindACML.cmake - eigen3/bench/btl/cmake/FindATLAS.cmake - eigen3/bench/btl/cmake/FindBlitz.cmake - eigen3/bench/btl/cmake/FindCBLAS.cmake - eigen3/bench/btl/cmake/FindGMM.cmake - eigen3/bench/btl/cmake/FindGOTO.cmake - eigen3/bench/btl/cmake/FindGOTO2.cmake - eigen3/bench/btl/cmake/FindMKL.cmake - eigen3/bench/btl/cmake/FindMTL4.cmake - eigen3/bench/btl/cmake/FindPackageHandleStandardArgs.cmake - eigen3/bench/btl/cmake/FindTvmet.cmake - eigen3/bench/btl/cmake/MacroOptionalAddSubdirectory.cmake - eigen3/bench/btl/CMakeLists.txt - eigen3/bench/btl/COPYING - eigen3/bench/btl/data/action_settings.txt - eigen3/bench/btl/data/CMakeLists.txt - eigen3/bench/btl/data/gnuplot_common_settings.hh - eigen3/bench/btl/data/go_mean - eigen3/bench/btl/data/mean.cxx - eigen3/bench/btl/data/mk_gnuplot_script.sh - eigen3/bench/btl/data/mk_mean_script.sh - eigen3/bench/btl/data/mk_new_gnuplot.sh - eigen3/bench/btl/data/perlib_plot_settings.txt - eigen3/bench/btl/data/regularize.cxx - eigen3/bench/btl/data/smooth.cxx - eigen3/bench/btl/data/smooth_all.sh - eigen3/bench/btl/generic_bench/bench.hh - eigen3/bench/btl/generic_bench/bench_parameter.hh - eigen3/bench/btl/generic_bench/btl.hh - eigen3/bench/btl/generic_bench/init/init_function.hh - eigen3/bench/btl/generic_bench/init/init_matrix.hh - eigen3/bench/btl/generic_bench/init/init_vector.hh - eigen3/bench/btl/generic_bench/static/bench_static.hh - eigen3/bench/btl/generic_bench/static/intel_bench_fixed_size.hh - eigen3/bench/btl/generic_bench/static/static_size_generator.hh - eigen3/bench/btl/generic_bench/timers/mixed_perf_analyzer.hh - eigen3/bench/btl/generic_bench/timers/portable_perf_analyzer.hh - eigen3/bench/btl/generic_bench/timers/portable_perf_analyzer_old.hh - eigen3/bench/btl/generic_bench/timers/portable_timer.hh - eigen3/bench/btl/generic_bench/timers/STL_perf_analyzer.hh - eigen3/bench/btl/generic_bench/timers/STL_timer.hh - eigen3/bench/btl/generic_bench/timers/x86_perf_analyzer.hh - eigen3/bench/btl/generic_bench/timers/x86_timer.hh - eigen3/bench/btl/generic_bench/utils/size_lin_log.hh - eigen3/bench/btl/generic_bench/utils/size_log.hh - eigen3/bench/btl/generic_bench/utils/utilities.h - eigen3/bench/btl/generic_bench/utils/xy_file.hh - eigen3/bench/btl/libs/BLAS/blas.h - eigen3/bench/btl/libs/BLAS/blas_interface.hh - eigen3/bench/btl/libs/BLAS/blas_interface_impl.hh - eigen3/bench/btl/libs/BLAS/c_interface_base.h - eigen3/bench/btl/libs/BLAS/CMakeLists.txt - eigen3/bench/btl/libs/BLAS/main.cpp - eigen3/bench/btl/libs/blitz/blitz_interface.hh - eigen3/bench/btl/libs/blitz/blitz_LU_solve_interface.hh - eigen3/bench/btl/libs/blitz/btl_blitz.cpp - eigen3/bench/btl/libs/blitz/btl_tiny_blitz.cpp - eigen3/bench/btl/libs/blitz/CMakeLists.txt - eigen3/bench/btl/libs/blitz/tiny_blitz_interface.hh - eigen3/bench/btl/libs/eigen2/btl_tiny_eigen2.cpp - eigen3/bench/btl/libs/eigen2/CMakeLists.txt - eigen3/bench/btl/libs/eigen2/eigen2_interface.hh - eigen3/bench/btl/libs/eigen2/main_adv.cpp - eigen3/bench/btl/libs/eigen2/main_linear.cpp - eigen3/bench/btl/libs/eigen2/main_matmat.cpp - eigen3/bench/btl/libs/eigen2/main_vecmat.cpp - eigen3/bench/btl/libs/eigen3/btl_tiny_eigen3.cpp - eigen3/bench/btl/libs/eigen3/CMakeLists.txt - eigen3/bench/btl/libs/eigen3/eigen3_interface.hh - eigen3/bench/btl/libs/eigen3/main_adv.cpp - eigen3/bench/btl/libs/eigen3/main_linear.cpp - eigen3/bench/btl/libs/eigen3/main_matmat.cpp - eigen3/bench/btl/libs/eigen3/main_vecmat.cpp - eigen3/bench/btl/libs/gmm/CMakeLists.txt - eigen3/bench/btl/libs/gmm/gmm_interface.hh - eigen3/bench/btl/libs/gmm/gmm_LU_solve_interface.hh - eigen3/bench/btl/libs/gmm/main.cpp - eigen3/bench/btl/libs/mtl4/.kdbgrc.main - eigen3/bench/btl/libs/mtl4/CMakeLists.txt - eigen3/bench/btl/libs/mtl4/main.cpp - eigen3/bench/btl/libs/mtl4/mtl4_interface.hh - eigen3/bench/btl/libs/mtl4/mtl4_LU_solve_interface.hh - eigen3/bench/btl/libs/STL/CMakeLists.txt - eigen3/bench/btl/libs/STL/main.cpp - eigen3/bench/btl/libs/STL/STL_interface.hh - eigen3/bench/btl/libs/tvmet/CMakeLists.txt - eigen3/bench/btl/libs/tvmet/main.cpp - eigen3/bench/btl/libs/tvmet/tvmet_interface.hh - eigen3/bench/btl/libs/ublas/CMakeLists.txt - eigen3/bench/btl/libs/ublas/main.cpp - eigen3/bench/btl/libs/ublas/ublas_interface.hh - eigen3/bench/btl/README - eigen3/bench/check_cache_queries.cpp - eigen3/bench/eig33.cpp - eigen3/bench/geometry.cpp - eigen3/bench/product_threshold.cpp - eigen3/bench/quat_slerp.cpp - eigen3/bench/quatmul.cpp - eigen3/bench/README.txt - eigen3/bench/sparse_cholesky.cpp - eigen3/bench/sparse_dense_product.cpp - eigen3/bench/sparse_lu.cpp - eigen3/bench/sparse_product.cpp - eigen3/bench/sparse_randomsetter.cpp - eigen3/bench/sparse_setter.cpp - eigen3/bench/sparse_transpose.cpp - eigen3/bench/sparse_trisolver.cpp - eigen3/bench/spbench/CMakeLists.txt - eigen3/bench/spbench/sp_solver.cpp - eigen3/bench/spbench/spbench.dtd - eigen3/bench/spbench/spbenchsolver.cpp - eigen3/bench/spbench/spbenchsolver.h - eigen3/bench/spbench/spbenchstyle.h - eigen3/bench/spbench/test_sparseLU.cpp - eigen3/bench/spmv.cpp - eigen3/bench/vdw_new.cpp eigen3/blas/BandTriangularSolver.h eigen3/blas/chbmv.f eigen3/blas/chpmv.f diff --git a/eigen3/bench/BenchSparseUtil.h b/eigen3/bench/BenchSparseUtil.h deleted file mode 100644 --- a/eigen3/bench/BenchSparseUtil.h +++ /dev/null @@ -1,149 +0,0 @@ - -#include -#include -#include - -using namespace std; -using namespace Eigen; -using namespace Eigen; - -#ifndef SIZE -#define SIZE 1024 -#endif - -#ifndef DENSITY -#define DENSITY 0.01 -#endif - -#ifndef SCALAR -#define SCALAR double -#endif - -typedef SCALAR Scalar; -typedef Matrix DenseMatrix; -typedef Matrix DenseVector; -typedef SparseMatrix EigenSparseMatrix; - -void fillMatrix(float density, int rows, int cols, EigenSparseMatrix& dst) -{ - dst.reserve(double(rows)*cols*density); - for(int j = 0; j < cols; j++) - { - for(int i = 0; i < rows; i++) - { - Scalar v = (internal::random(0,1) < density) ? internal::random() : 0; - if (v!=0) - dst.insert(i,j) = v; - } - } - dst.finalize(); -} - -void fillMatrix2(int nnzPerCol, int rows, int cols, EigenSparseMatrix& dst) -{ -// std::cout << "alloc " << nnzPerCol*cols << "\n"; - dst.reserve(nnzPerCol*cols); - for(int j = 0; j < cols; j++) - { - std::set aux; - for(int i = 0; i < nnzPerCol; i++) - { - int k = internal::random(0,rows-1); - while (aux.find(k)!=aux.end()) - k = internal::random(0,rows-1); - aux.insert(k); - - dst.insert(k,j) = internal::random(); - } - } - dst.finalize(); -} - -void eiToDense(const EigenSparseMatrix& src, DenseMatrix& dst) -{ - dst.setZero(); - for (int j=0; j GmmSparse; -typedef gmm::col_matrix< gmm::wsvector > GmmDynSparse; -void eiToGmm(const EigenSparseMatrix& src, GmmSparse& dst) -{ - GmmDynSparse tmp(src.rows(), src.cols()); - for (int j=0; j -typedef mtl::compressed2D > MtlSparse; -typedef mtl::compressed2D > MtlSparseRowMajor; -void eiToMtl(const EigenSparseMatrix& src, MtlSparse& dst) -{ - mtl::matrix::inserter ins(dst); - for (int j=0; j -#include -#include -#include -#include -#include -#include -#include - -typedef boost::numeric::ublas::compressed_matrix UBlasSparse; - -void eiToUblas(const EigenSparseMatrix& src, UBlasSparse& dst) -{ - dst.resize(src.rows(), src.cols(), false); - for (int j=0; j -void eiToUblasVec(const EigenType& src, UblasType& dst) -{ - dst.resize(src.size()); - for (int j=0; j -} -#endif diff --git a/eigen3/bench/BenchTimer.h b/eigen3/bench/BenchTimer.h deleted file mode 100644 --- a/eigen3/bench/BenchTimer.h +++ /dev/null @@ -1,187 +0,0 @@ -// This file is part of Eigen, a lightweight C++ template library -// for linear algebra. -// -// Copyright (C) 2008-2010 Gael Guennebaud -// Copyright (C) 2009 Benoit Jacob -// -// This Source Code Form is subject to the terms of the Mozilla -// Public License v. 2.0. If a copy of the MPL was not distributed -// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. - -#ifndef EIGEN_BENCH_TIMERR_H -#define EIGEN_BENCH_TIMERR_H - -#if defined(_WIN32) || defined(__CYGWIN__) -# ifndef NOMINMAX -# define NOMINMAX -# define EIGEN_BT_UNDEF_NOMINMAX -# endif -# ifndef WIN32_LEAN_AND_MEAN -# define WIN32_LEAN_AND_MEAN -# define EIGEN_BT_UNDEF_WIN32_LEAN_AND_MEAN -# endif -# include -#elif defined(__APPLE__) -#include -#include -#else -# include -#endif - -#include - -namespace Eigen -{ - -enum { - CPU_TIMER = 0, - REAL_TIMER = 1 -}; - -/** Elapsed time timer keeping the best try. - * - * On POSIX platforms we use clock_gettime with CLOCK_PROCESS_CPUTIME_ID. - * On Windows we use QueryPerformanceCounter - * - * Important: on linux, you must link with -lrt - */ -class BenchTimer -{ -public: - - BenchTimer() - { -#if defined(_WIN32) || defined(__CYGWIN__) - LARGE_INTEGER freq; - QueryPerformanceFrequency(&freq); - m_frequency = (double)freq.QuadPart; -#endif - reset(); - } - - ~BenchTimer() {} - - inline void reset() - { - m_bests.fill(1e9); - m_worsts.fill(0); - m_totals.setZero(); - } - inline void start() - { - m_starts[CPU_TIMER] = getCpuTime(); - m_starts[REAL_TIMER] = getRealTime(); - } - inline void stop() - { - m_times[CPU_TIMER] = getCpuTime() - m_starts[CPU_TIMER]; - m_times[REAL_TIMER] = getRealTime() - m_starts[REAL_TIMER]; - #if EIGEN_VERSION_AT_LEAST(2,90,0) - m_bests = m_bests.cwiseMin(m_times); - m_worsts = m_worsts.cwiseMax(m_times); - #else - m_bests(0) = std::min(m_bests(0),m_times(0)); - m_bests(1) = std::min(m_bests(1),m_times(1)); - m_worsts(0) = std::max(m_worsts(0),m_times(0)); - m_worsts(1) = std::max(m_worsts(1),m_times(1)); - #endif - m_totals += m_times; - } - - /** Return the elapsed time in seconds between the last start/stop pair - */ - inline double value(int TIMER = CPU_TIMER) const - { - return m_times[TIMER]; - } - - /** Return the best elapsed time in seconds - */ - inline double best(int TIMER = CPU_TIMER) const - { - return m_bests[TIMER]; - } - - /** Return the worst elapsed time in seconds - */ - inline double worst(int TIMER = CPU_TIMER) const - { - return m_worsts[TIMER]; - } - - /** Return the total elapsed time in seconds. - */ - inline double total(int TIMER = CPU_TIMER) const - { - return m_totals[TIMER]; - } - - inline double getCpuTime() const - { -#ifdef _WIN32 - LARGE_INTEGER query_ticks; - QueryPerformanceCounter(&query_ticks); - return query_ticks.QuadPart/m_frequency; -#elif __APPLE__ - return double(mach_absolute_time())*1e-9; -#else - timespec ts; - clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts); - return double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec); -#endif - } - - inline double getRealTime() const - { -#ifdef _WIN32 - SYSTEMTIME st; - GetSystemTime(&st); - return (double)st.wSecond + 1.e-3 * (double)st.wMilliseconds; -#elif __APPLE__ - return double(mach_absolute_time())*1e-9; -#else - timespec ts; - clock_gettime(CLOCK_REALTIME, &ts); - return double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec); -#endif - } - -protected: -#if defined(_WIN32) || defined(__CYGWIN__) - double m_frequency; -#endif - Vector2d m_starts; - Vector2d m_times; - Vector2d m_bests; - Vector2d m_worsts; - Vector2d m_totals; - -public: - EIGEN_MAKE_ALIGNED_OPERATOR_NEW -}; - -#define BENCH(TIMER,TRIES,REP,CODE) { \ - TIMER.reset(); \ - for(int uglyvarname1=0; uglyvarname1 -#include "BenchTimer.h" - -using namespace std; -using namespace Eigen; - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -template void initMatrix_random(MatrixType& mat) __attribute__((noinline)); -template void initMatrix_random(MatrixType& mat) -{ - mat.setRandom();// = MatrixType::random(mat.rows(), mat.cols()); -} - -template void initMatrix_identity(MatrixType& mat) __attribute__((noinline)); -template void initMatrix_identity(MatrixType& mat) -{ - mat.setIdentity(); -} - -#ifndef __INTEL_COMPILER -#define DISABLE_SSE_EXCEPTIONS() { \ - int aux; \ - asm( \ - "stmxcsr %[aux] \n\t" \ - "orl $32832, %[aux] \n\t" \ - "ldmxcsr %[aux] \n\t" \ - : : [aux] "m" (aux)); \ -} -#else -#define DISABLE_SSE_EXCEPTIONS() -#endif - -#ifdef BENCH_GMM -#include -template -void eiToGmm(const EigenMatrixType& src, GmmMatrixType& dst) -{ - dst.resize(src.rows(),src.cols()); - for (int j=0; j -#include -#include -template -void eiToGsl(const EigenMatrixType& src, gsl_matrix** dst) -{ - for (int j=0; j -#include -template -void eiToUblas(const EigenMatrixType& src, UblasMatrixType& dst) -{ - dst.resize(src.rows(),src.cols()); - for (int j=0; j -void eiToUblasVec(const EigenType& src, UblasType& dst) -{ - dst.resize(src.size()); - for (int j=0; j x0.869674 (2) - double, 128x128: 0.054148s 0.0419669s => x1.29025 (2) - double, 512x512: 0.913799s 0.428533s => x2.13239 (2) - double, 1024x1024: 14.5972s 9.3542s => x1.5605 (2) - - icpc -fast -DNDEBUG -fno-exceptions -no-inline-max-size -openmp - double, fixed-size 4x4: 0.000589848s 0.019949s - double, 32x32: 0.0682781s 0.0449722s => x1.51823 (2) - double, 128x128: 0.0547509s 0.0435519s => x1.25714 (2) - double, 512x512: 0.829436s 0.424438s => x1.9542 (2) - double, 1024x1024: 14.5243s 10.7735s => x1.34815 (2) - - - diff --git a/eigen3/bench/basicbench.cxxlist b/eigen3/bench/basicbench.cxxlist deleted file mode 100644 --- a/eigen3/bench/basicbench.cxxlist +++ /dev/null @@ -1,28 +0,0 @@ -#!/bin/bash - -# CLIST[((g++))]="g++-3.4 -O3 -DNDEBUG" -# CLIST[((g++))]="g++-3.4 -O3 -DNDEBUG -finline-limit=20000" - -# CLIST[((g++))]="g++-4.1 -O3 -DNDEBUG" -#CLIST[((g++))]="g++-4.1 -O3 -DNDEBUG -finline-limit=20000" - -# CLIST[((g++))]="g++-4.2 -O3 -DNDEBUG" -#CLIST[((g++))]="g++-4.2 -O3 -DNDEBUG -finline-limit=20000" -# CLIST[((g++))]="g++-4.2 -O3 -DNDEBUG -finline-limit=20000 -fprofile-generate" -# CLIST[((g++))]="g++-4.2 -O3 -DNDEBUG -finline-limit=20000 -fprofile-use" - -# CLIST[((g++))]="g++-4.3 -O3 -DNDEBUG" -#CLIST[((g++))]="g++-4.3 -O3 -DNDEBUG -finline-limit=20000" -# CLIST[((g++))]="g++-4.3 -O3 -DNDEBUG -finline-limit=20000 -fprofile-generate" -# CLIST[((g++))]="g++-4.3 -O3 -DNDEBUG -finline-limit=20000 -fprofile-use" - -# CLIST[((g++))]="icpc -fast -DNDEBUG -fno-exceptions -no-inline-max-size -prof-genx" -# CLIST[((g++))]="icpc -fast -DNDEBUG -fno-exceptions -no-inline-max-size -prof-use" - -#CLIST[((g++))]="/opt/intel/Compiler/11.1/072/bin/intel64/icpc -fast -DNDEBUG -fno-exceptions -no-inline-max-size -lrt" -CLIST[((g++))]="/home/orzel/svn/llvm/Release/bin/clang++ -O3 -DNDEBUG -DEIGEN_DONT_VECTORIZE -lrt" -CLIST[((g++))]="/home/orzel/svn/llvm/Release/bin/clang++ -O3 -DNDEBUG -lrt" -CLIST[((g++))]="g++-4.4.4 -O3 -DNDEBUG -DEIGEN_DONT_VECTORIZE -lrt" -CLIST[((g++))]="g++-4.4.4 -O3 -DNDEBUG -lrt" -CLIST[((g++))]="g++-4.5.0 -O3 -DNDEBUG -DEIGEN_DONT_VECTORIZE -lrt" -CLIST[((g++))]="g++-4.5.0 -O3 -DNDEBUG -lrt" diff --git a/eigen3/bench/basicbenchmark.cpp b/eigen3/bench/basicbenchmark.cpp deleted file mode 100644 --- a/eigen3/bench/basicbenchmark.cpp +++ /dev/null @@ -1,35 +0,0 @@ - -#include -#include "BenchUtil.h" -#include "basicbenchmark.h" - -int main(int argc, char *argv[]) -{ - DISABLE_SSE_EXCEPTIONS(); - - // this is the list of matrix type and size we want to bench: - // ((suffix) (matrix size) (number of iterations)) - #define MODES ((3d)(3)(4000000)) ((4d)(4)(1000000)) ((Xd)(4)(1000000)) ((Xd)(20)(10000)) -// #define MODES ((Xd)(20)(10000)) - - #define _GENERATE_HEADER(R,ARG,EL) << BOOST_PP_STRINGIZE(BOOST_PP_SEQ_HEAD(EL)) << "-" \ - << BOOST_PP_STRINGIZE(BOOST_PP_SEQ_ELEM(1,EL)) << "x" \ - << BOOST_PP_STRINGIZE(BOOST_PP_SEQ_ELEM(1,EL)) << " / " - - std::cout BOOST_PP_SEQ_FOR_EACH(_GENERATE_HEADER, ~, MODES ) << endl; - - const int tries = 10; - - #define _RUN_BENCH(R,ARG,EL) \ - std::cout << ARG( \ - BOOST_PP_CAT(Matrix, BOOST_PP_SEQ_HEAD(EL)) (\ - BOOST_PP_SEQ_ELEM(1,EL),BOOST_PP_SEQ_ELEM(1,EL)), BOOST_PP_SEQ_ELEM(2,EL), tries) \ - << " "; - - BOOST_PP_SEQ_FOR_EACH(_RUN_BENCH, benchBasic, MODES ); - std::cout << endl; - BOOST_PP_SEQ_FOR_EACH(_RUN_BENCH, benchBasic, MODES ); - std::cout << endl; - - return 0; -} diff --git a/eigen3/bench/basicbenchmark.h b/eigen3/bench/basicbenchmark.h deleted file mode 100644 --- a/eigen3/bench/basicbenchmark.h +++ /dev/null @@ -1,63 +0,0 @@ - -#ifndef EIGEN_BENCH_BASICBENCH_H -#define EIGEN_BENCH_BASICBENCH_H - -enum {LazyEval, EarlyEval, OmpEval}; - -template -void benchBasic_loop(const MatrixType& I, MatrixType& m, int iterations) __attribute__((noinline)); - -template -void benchBasic_loop(const MatrixType& I, MatrixType& m, int iterations) -{ - for(int a = 0; a < iterations; a++) - { - if (Mode==LazyEval) - { - asm("#begin_bench_loop LazyEval"); - if (MatrixType::SizeAtCompileTime!=Eigen::Dynamic) asm("#fixedsize"); - m = (I + 0.00005 * (m + m.lazy() * m)).eval(); - } - else if (Mode==OmpEval) - { - asm("#begin_bench_loop OmpEval"); - if (MatrixType::SizeAtCompileTime!=Eigen::Dynamic) asm("#fixedsize"); - m = (I + 0.00005 * (m + m.lazy() * m)).evalOMP(); - } - else - { - asm("#begin_bench_loop EarlyEval"); - if (MatrixType::SizeAtCompileTime!=Eigen::Dynamic) asm("#fixedsize"); - m = I + 0.00005 * (m + m * m); - } - asm("#end_bench_loop"); - } -} - -template -double benchBasic(const MatrixType& mat, int size, int tries) __attribute__((noinline)); - -template -double benchBasic(const MatrixType& mat, int iterations, int tries) -{ - const int rows = mat.rows(); - const int cols = mat.cols(); - - MatrixType I(rows,cols); - MatrixType m(rows,cols); - - initMatrix_identity(I); - - Eigen::BenchTimer timer; - for(uint t=0; t(I, m, iterations); - timer.stop(); - cerr << m; - } - return timer.value(); -}; - -#endif // EIGEN_BENCH_BASICBENCH_H diff --git a/eigen3/bench/benchBlasGemm.cpp b/eigen3/bench/benchBlasGemm.cpp deleted file mode 100644 --- a/eigen3/bench/benchBlasGemm.cpp +++ /dev/null @@ -1,219 +0,0 @@ -// g++ -O3 -DNDEBUG -I.. -L /usr/lib64/atlas/ benchBlasGemm.cpp -o benchBlasGemm -lrt -lcblas -// possible options: -// -DEIGEN_DONT_VECTORIZE -// -msse2 - -// #define EIGEN_DEFAULT_TO_ROW_MAJOR -#define _FLOAT - -#include - -#include -#include "BenchTimer.h" - -// include the BLAS headers -extern "C" { -#include -} -#include - -#ifdef _FLOAT -typedef float Scalar; -#define CBLAS_GEMM cblas_sgemm -#else -typedef double Scalar; -#define CBLAS_GEMM cblas_dgemm -#endif - - -typedef Eigen::Matrix MyMatrix; -void bench_eigengemm(MyMatrix& mc, const MyMatrix& ma, const MyMatrix& mb, int nbloops); -void check_product(int M, int N, int K); -void check_product(void); - -int main(int argc, char *argv[]) -{ - // disable SSE exceptions - #ifdef __GNUC__ - { - int aux; - asm( - "stmxcsr %[aux] \n\t" - "orl $32832, %[aux] \n\t" - "ldmxcsr %[aux] \n\t" - : : [aux] "m" (aux)); - } - #endif - - int nbtries=1, nbloops=1, M, N, K; - - if (argc==2) - { - if (std::string(argv[1])=="check") - check_product(); - else - M = N = K = atoi(argv[1]); - } - else if ((argc==3) && (std::string(argv[1])=="auto")) - { - M = N = K = atoi(argv[2]); - nbloops = 1000000000/(M*M*M); - if (nbloops<1) - nbloops = 1; - nbtries = 6; - } - else if (argc==4) - { - M = N = K = atoi(argv[1]); - nbloops = atoi(argv[2]); - nbtries = atoi(argv[3]); - } - else if (argc==6) - { - M = atoi(argv[1]); - N = atoi(argv[2]); - K = atoi(argv[3]); - nbloops = atoi(argv[4]); - nbtries = atoi(argv[5]); - } - else - { - std::cout << "Usage: " << argv[0] << " size \n"; - std::cout << "Usage: " << argv[0] << " auto size\n"; - std::cout << "Usage: " << argv[0] << " size nbloops nbtries\n"; - std::cout << "Usage: " << argv[0] << " M N K nbloops nbtries\n"; - std::cout << "Usage: " << argv[0] << " check\n"; - std::cout << "Options:\n"; - std::cout << " size unique size of the 2 matrices (integer)\n"; - std::cout << " auto automatically set the number of repetitions and tries\n"; - std::cout << " nbloops number of times the GEMM routines is executed\n"; - std::cout << " nbtries number of times the loop is benched (return the best try)\n"; - std::cout << " M N K sizes of the matrices: MxN = MxK * KxN (integers)\n"; - std::cout << " check check eigen product using cblas as a reference\n"; - exit(1); - } - - double nbmad = double(M) * double(N) * double(K) * double(nbloops); - - if (!(std::string(argv[1])=="auto")) - std::cout << M << " x " << N << " x " << K << "\n"; - - Scalar alpha, beta; - MyMatrix ma(M,K), mb(K,N), mc(M,N); - ma = MyMatrix::Random(M,K); - mb = MyMatrix::Random(K,N); - mc = MyMatrix::Random(M,N); - - Eigen::BenchTimer timer; - - // we simply compute c += a*b, so: - alpha = 1; - beta = 1; - - // bench cblas - // ROWS_A, COLS_B, COLS_A, 1.0, A, COLS_A, B, COLS_B, 0.0, C, COLS_B); - if (!(std::string(argv[1])=="auto")) - { - timer.reset(); - for (uint k=0 ; k(1,64); - N = internal::random(1,768); - K = internal::random(1,768); - M = (0 + M) * 1; - std::cout << M << " x " << N << " x " << K << "\n"; - check_product(M, N, K); - } -} - diff --git a/eigen3/bench/benchCholesky.cpp b/eigen3/bench/benchCholesky.cpp deleted file mode 100644 --- a/eigen3/bench/benchCholesky.cpp +++ /dev/null @@ -1,142 +0,0 @@ - -// g++ -DNDEBUG -O3 -I.. benchLLT.cpp -o benchLLT && ./benchLLT -// options: -// -DBENCH_GSL -lgsl /usr/lib/libcblas.so.3 -// -DEIGEN_DONT_VECTORIZE -// -msse2 -// -DREPEAT=100 -// -DTRIES=10 -// -DSCALAR=double - -#include - -#include -#include -#include -using namespace Eigen; - -#ifndef REPEAT -#define REPEAT 10000 -#endif - -#ifndef TRIES -#define TRIES 10 -#endif - -typedef float Scalar; - -template -__attribute__ ((noinline)) void benchLLT(const MatrixType& m) -{ - int rows = m.rows(); - int cols = m.cols(); - - int cost = 0; - for (int j=0; j SquareMatrixType; - - MatrixType a = MatrixType::Random(rows,cols); - SquareMatrixType covMat = a * a.adjoint(); - - BenchTimer timerNoSqrt, timerSqrt; - - Scalar acc = 0; - int r = internal::random(0,covMat.rows()-1); - int c = internal::random(0,covMat.cols()-1); - for (int t=0; t cholnosqrt(covMat); - acc += cholnosqrt.matrixL().coeff(r,c); - } - timerNoSqrt.stop(); - } - - for (int t=0; t chol(covMat); - acc += chol.matrixL().coeff(r,c); - } - timerSqrt.stop(); - } - - if (MatrixType::RowsAtCompileTime==Dynamic) - std::cout << "dyn "; - else - std::cout << "fixed "; - std::cout << covMat.rows() << " \t" - << (timerNoSqrt.value() * REPEAT) / repeats << "s " - << "(" << 1e-6 * cost*repeats/timerNoSqrt.value() << " MFLOPS)\t" - << (timerSqrt.value() * REPEAT) / repeats << "s " - << "(" << 1e-6 * cost*repeats/timerSqrt.value() << " MFLOPS)\n"; - - - #ifdef BENCH_GSL - if (MatrixType::RowsAtCompileTime==Dynamic) - { - timerSqrt.reset(); - - gsl_matrix* gslCovMat = gsl_matrix_alloc(covMat.rows(),covMat.cols()); - gsl_matrix* gslCopy = gsl_matrix_alloc(covMat.rows(),covMat.cols()); - - eiToGsl(covMat, &gslCovMat); - for (int t=0; t0; ++i) - benchLLT(Matrix(dynsizes[i],dynsizes[i])); - - benchLLT(Matrix()); - benchLLT(Matrix()); - benchLLT(Matrix()); - benchLLT(Matrix()); - benchLLT(Matrix()); - benchLLT(Matrix()); - benchLLT(Matrix()); - benchLLT(Matrix()); - benchLLT(Matrix()); - return 0; -} - diff --git a/eigen3/bench/benchEigenSolver.cpp b/eigen3/bench/benchEigenSolver.cpp deleted file mode 100644 --- a/eigen3/bench/benchEigenSolver.cpp +++ /dev/null @@ -1,212 +0,0 @@ - -// g++ -DNDEBUG -O3 -I.. benchEigenSolver.cpp -o benchEigenSolver && ./benchEigenSolver -// options: -// -DBENCH_GMM -// -DBENCH_GSL -lgsl /usr/lib/libcblas.so.3 -// -DEIGEN_DONT_VECTORIZE -// -msse2 -// -DREPEAT=100 -// -DTRIES=10 -// -DSCALAR=double - -#include - -#include -#include -#include -using namespace Eigen; - -#ifndef REPEAT -#define REPEAT 1000 -#endif - -#ifndef TRIES -#define TRIES 4 -#endif - -#ifndef SCALAR -#define SCALAR float -#endif - -typedef SCALAR Scalar; - -template -__attribute__ ((noinline)) void benchEigenSolver(const MatrixType& m) -{ - int rows = m.rows(); - int cols = m.cols(); - - int stdRepeats = std::max(1,int((REPEAT*1000)/(rows*rows*sqrt(rows)))); - int saRepeats = stdRepeats * 4; - - typedef typename MatrixType::Scalar Scalar; - typedef Matrix SquareMatrixType; - - MatrixType a = MatrixType::Random(rows,cols); - SquareMatrixType covMat = a * a.adjoint(); - - BenchTimer timerSa, timerStd; - - Scalar acc = 0; - int r = internal::random(0,covMat.rows()-1); - int c = internal::random(0,covMat.cols()-1); - { - SelfAdjointEigenSolver ei(covMat); - for (int t=0; t ei(covMat); - for (int t=0; t gmmCovMat(covMat.rows(),covMat.cols()); - gmm::dense_matrix eigvect(covMat.rows(),covMat.cols()); - std::vector eigval(covMat.rows()); - eiToGmm(covMat, gmmCovMat); - for (int t=0; t0; ++i) - benchEigenSolver(Matrix(dynsizes[i],dynsizes[i])); - - benchEigenSolver(Matrix()); - benchEigenSolver(Matrix()); - benchEigenSolver(Matrix()); - benchEigenSolver(Matrix()); - benchEigenSolver(Matrix()); - benchEigenSolver(Matrix()); - benchEigenSolver(Matrix()); - return 0; -} - diff --git a/eigen3/bench/benchFFT.cpp b/eigen3/bench/benchFFT.cpp deleted file mode 100644 --- a/eigen3/bench/benchFFT.cpp +++ /dev/null @@ -1,115 +0,0 @@ -// This file is part of Eigen, a lightweight C++ template library -// for linear algebra. -// -// Copyright (C) 2009 Mark Borgerding mark a borgerding net -// -// This Source Code Form is subject to the terms of the Mozilla -// Public License v. 2.0. If a copy of the MPL was not distributed -// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. - -#include - -#include -#include -#include -#include - -#include - -using namespace Eigen; -using namespace std; - - -template -string nameof(); - -template <> string nameof() {return "float";} -template <> string nameof() {return "double";} -template <> string nameof() {return "long double";} - -#ifndef TYPE -#define TYPE float -#endif - -#ifndef NFFT -#define NFFT 1024 -#endif -#ifndef NDATA -#define NDATA 1000000 -#endif - -using namespace Eigen; - -template -void bench(int nfft,bool fwd,bool unscaled=false, bool halfspec=false) -{ - typedef typename NumTraits::Real Scalar; - typedef typename std::complex Complex; - int nits = NDATA/nfft; - vector inbuf(nfft); - vector outbuf(nfft); - FFT< Scalar > fft; - - if (unscaled) { - fft.SetFlag(fft.Unscaled); - cout << "unscaled "; - } - if (halfspec) { - fft.SetFlag(fft.HalfSpectrum); - cout << "halfspec "; - } - - - std::fill(inbuf.begin(),inbuf.end(),0); - fft.fwd( outbuf , inbuf); - - BenchTimer timer; - timer.reset(); - for (int k=0;k<8;++k) { - timer.start(); - if (fwd) - for(int i = 0; i < nits; i++) - fft.fwd( outbuf , inbuf); - else - for(int i = 0; i < nits; i++) - fft.inv(inbuf,outbuf); - timer.stop(); - } - - cout << nameof() << " "; - double mflops = 5.*nfft*log2((double)nfft) / (1e6 * timer.value() / (double)nits ); - if ( NumTraits::IsComplex ) { - cout << "complex"; - }else{ - cout << "real "; - mflops /= 2; - } - - - if (fwd) - cout << " fwd"; - else - cout << " inv"; - - cout << " NFFT=" << nfft << " " << (double(1e-6*nfft*nits)/timer.value()) << " MS/s " << mflops << "MFLOPS\n"; -} - -int main(int argc,char ** argv) -{ - bench >(NFFT,true); - bench >(NFFT,false); - bench(NFFT,true); - bench(NFFT,false); - bench(NFFT,false,true); - bench(NFFT,false,true,true); - - bench >(NFFT,true); - bench >(NFFT,false); - bench(NFFT,true); - bench(NFFT,false); - bench >(NFFT,true); - bench >(NFFT,false); - bench(NFFT,true); - bench(NFFT,false); - return 0; -} diff --git a/eigen3/bench/benchGeometry.cpp b/eigen3/bench/benchGeometry.cpp deleted file mode 100644 --- a/eigen3/bench/benchGeometry.cpp +++ /dev/null @@ -1,134 +0,0 @@ -#include -#include -#include -#include -#include - -using namespace Eigen; -using namespace std; - -#ifndef REPEAT -#define REPEAT 1000000 -#endif - -enum func_opt -{ - TV, - TMATV, - TMATVMAT, -}; - - -template -struct func; - -template -struct func -{ - static EIGEN_DONT_INLINE res run( arg1& a1, arg2& a2 ) - { - asm (""); - return a1 * a2; - } -}; - -template -struct func -{ - static EIGEN_DONT_INLINE res run( arg1& a1, arg2& a2 ) - { - asm (""); - return a1.matrix() * a2; - } -}; - -template -struct func -{ - static EIGEN_DONT_INLINE res run( arg1& a1, arg2& a2 ) - { - asm (""); - return res(a1.matrix() * a2.matrix()); - } -}; - -template -struct test_transform -{ - static void run() - { - arg1 a1; - a1.setIdentity(); - arg2 a2; - a2.setIdentity(); - - BenchTimer timer; - timer.reset(); - for (int k=0; k<10; ++k) - { - timer.start(); - for (int k=0; k Trans;\ - typedef Matrix Vec;\ - typedef func Func;\ - test_transform< Func, Trans, Vec >::run();\ - } - -#define run_trans( op, scalar, mode, option ) \ - std::cout << #scalar << "\t " << #mode << "\t " << #option << " "; \ - {\ - typedef Transform Trans;\ - typedef func Func;\ - test_transform< Func, Trans, Trans >::run();\ - } - -int main(int argc, char* argv[]) -{ - cout << "vec = trans * vec" << endl; - run_vec(TV, float, Isometry, AutoAlign, 3); - run_vec(TV, float, Isometry, DontAlign, 3); - run_vec(TV, float, Isometry, AutoAlign, 4); - run_vec(TV, float, Isometry, DontAlign, 4); - run_vec(TV, float, Projective, AutoAlign, 4); - run_vec(TV, float, Projective, DontAlign, 4); - run_vec(TV, double, Isometry, AutoAlign, 3); - run_vec(TV, double, Isometry, DontAlign, 3); - run_vec(TV, double, Isometry, AutoAlign, 4); - run_vec(TV, double, Isometry, DontAlign, 4); - run_vec(TV, double, Projective, AutoAlign, 4); - run_vec(TV, double, Projective, DontAlign, 4); - - cout << "vec = trans.matrix() * vec" << endl; - run_vec(TMATV, float, Isometry, AutoAlign, 4); - run_vec(TMATV, float, Isometry, DontAlign, 4); - run_vec(TMATV, double, Isometry, AutoAlign, 4); - run_vec(TMATV, double, Isometry, DontAlign, 4); - - cout << "trans = trans1 * trans" << endl; - run_trans(TV, float, Isometry, AutoAlign); - run_trans(TV, float, Isometry, DontAlign); - run_trans(TV, double, Isometry, AutoAlign); - run_trans(TV, double, Isometry, DontAlign); - run_trans(TV, float, Projective, AutoAlign); - run_trans(TV, float, Projective, DontAlign); - run_trans(TV, double, Projective, AutoAlign); - run_trans(TV, double, Projective, DontAlign); - - cout << "trans = trans1.matrix() * trans.matrix()" << endl; - run_trans(TMATVMAT, float, Isometry, AutoAlign); - run_trans(TMATVMAT, float, Isometry, DontAlign); - run_trans(TMATVMAT, double, Isometry, AutoAlign); - run_trans(TMATVMAT, double, Isometry, DontAlign); -} - diff --git a/eigen3/bench/benchVecAdd.cpp b/eigen3/bench/benchVecAdd.cpp deleted file mode 100644 --- a/eigen3/bench/benchVecAdd.cpp +++ /dev/null @@ -1,135 +0,0 @@ - -#include -#include -#include -using namespace Eigen; - -#ifndef SIZE -#define SIZE 50 -#endif - -#ifndef REPEAT -#define REPEAT 10000 -#endif - -typedef float Scalar; - -__attribute__ ((noinline)) void benchVec(Scalar* a, Scalar* b, Scalar* c, int size); -__attribute__ ((noinline)) void benchVec(MatrixXf& a, MatrixXf& b, MatrixXf& c); -__attribute__ ((noinline)) void benchVec(VectorXf& a, VectorXf& b, VectorXf& c); - -int main(int argc, char* argv[]) -{ - int size = SIZE * 8; - int size2 = size * size; - Scalar* a = internal::aligned_new(size2); - Scalar* b = internal::aligned_new(size2+4)+1; - Scalar* c = internal::aligned_new(size2); - - for (int i=0; i2 ; --innersize) - { - if (size2%innersize==0) - { - int outersize = size2/innersize; - MatrixXf ma = Map(a, innersize, outersize ); - MatrixXf mb = Map(b, innersize, outersize ); - MatrixXf mc = Map(c, innersize, outersize ); - timer.reset(); - for (int k=0; k<3; ++k) - { - timer.start(); - benchVec(ma, mb, mc); - timer.stop(); - } - std::cout << innersize << " x " << outersize << " " << timer.value() << "s " << (double(size2*REPEAT)/timer.value())/(1024.*1024.*1024.) << " GFlops\n"; - } - } - - VectorXf va = Map(a, size2); - VectorXf vb = Map(b, size2); - VectorXf vc = Map(c, size2); - timer.reset(); - for (int k=0; k<3; ++k) - { - timer.start(); - benchVec(va, vb, vc); - timer.stop(); - } - std::cout << timer.value() << "s " << (double(size2*REPEAT)/timer.value())/(1024.*1024.*1024.) << " GFlops\n"; - - return 0; -} - -void benchVec(MatrixXf& a, MatrixXf& b, MatrixXf& c) -{ - for (int k=0; k::type PacketScalar; - const int PacketSize = internal::packet_traits::size; - PacketScalar a0, a1, a2, a3, b0, b1, b2, b3; - for (int k=0; k -#include -#include - -using namespace std; -using namespace Eigen; - -#ifndef SCALAR -// #define SCALAR std::complex -#define SCALAR float -#endif - -typedef SCALAR Scalar; -typedef NumTraits::Real RealScalar; -typedef Matrix A; -typedef Matrix B; -typedef Matrix C; -typedef Matrix M; - -#ifdef HAVE_BLAS - -extern "C" { - #include -} - -static float fone = 1; -static float fzero = 0; -static double done = 1; -static double szero = 0; -static std::complex cfone = 1; -static std::complex cfzero = 0; -static std::complex cdone = 1; -static std::complex cdzero = 0; -static char notrans = 'N'; -static char trans = 'T'; -static char nonunit = 'N'; -static char lower = 'L'; -static char right = 'R'; -static int intone = 1; - -void blas_gemm(const MatrixXf& a, const MatrixXf& b, MatrixXf& c) -{ - int M = c.rows(); int N = c.cols(); int K = a.cols(); - int lda = a.rows(); int ldb = b.rows(); int ldc = c.rows(); - - sgemm_(¬rans,¬rans,&M,&N,&K,&fone, - const_cast(a.data()),&lda, - const_cast(b.data()),&ldb,&fone, - c.data(),&ldc); -} - -EIGEN_DONT_INLINE void blas_gemm(const MatrixXd& a, const MatrixXd& b, MatrixXd& c) -{ - int M = c.rows(); int N = c.cols(); int K = a.cols(); - int lda = a.rows(); int ldb = b.rows(); int ldc = c.rows(); - - dgemm_(¬rans,¬rans,&M,&N,&K,&done, - const_cast(a.data()),&lda, - const_cast(b.data()),&ldb,&done, - c.data(),&ldc); -} - -void blas_gemm(const MatrixXcf& a, const MatrixXcf& b, MatrixXcf& c) -{ - int M = c.rows(); int N = c.cols(); int K = a.cols(); - int lda = a.rows(); int ldb = b.rows(); int ldc = c.rows(); - - cgemm_(¬rans,¬rans,&M,&N,&K,(float*)&cfone, - const_cast((const float*)a.data()),&lda, - const_cast((const float*)b.data()),&ldb,(float*)&cfone, - (float*)c.data(),&ldc); -} - -void blas_gemm(const MatrixXcd& a, const MatrixXcd& b, MatrixXcd& c) -{ - int M = c.rows(); int N = c.cols(); int K = a.cols(); - int lda = a.rows(); int ldb = b.rows(); int ldc = c.rows(); - - zgemm_(¬rans,¬rans,&M,&N,&K,(double*)&cdone, - const_cast((const double*)a.data()),&lda, - const_cast((const double*)b.data()),&ldb,(double*)&cdone, - (double*)c.data(),&ldc); -} - - - -#endif - -void matlab_cplx_cplx(const M& ar, const M& ai, const M& br, const M& bi, M& cr, M& ci) -{ - cr.noalias() += ar * br; - cr.noalias() -= ai * bi; - ci.noalias() += ar * bi; - ci.noalias() += ai * br; -} - -void matlab_real_cplx(const M& a, const M& br, const M& bi, M& cr, M& ci) -{ - cr.noalias() += a * br; - ci.noalias() += a * bi; -} - -void matlab_cplx_real(const M& ar, const M& ai, const M& b, M& cr, M& ci) -{ - cr.noalias() += ar * b; - ci.noalias() += ai * b; -} - -template -EIGEN_DONT_INLINE void gemm(const A& a, const B& b, C& c) -{ - c.noalias() += a * b; -} - -int main(int argc, char ** argv) -{ - std::ptrdiff_t l1 = internal::queryL1CacheSize(); - std::ptrdiff_t l2 = internal::queryTopLevelCacheSize(); - std::cout << "L1 cache size = " << (l1>0 ? l1/1024 : -1) << " KB\n"; - std::cout << "L2/L3 cache size = " << (l2>0 ? l2/1024 : -1) << " KB\n"; - typedef internal::gebp_traits Traits; - std::cout << "Register blocking = " << Traits::mr << " x " << Traits::nr << "\n"; - - int rep = 1; // number of repetitions per try - int tries = 2; // number of tries, we keep the best - - int s = 2048; - int cache_size = -1; - - bool need_help = false; - for (int i=1; i c t p\n"; - return 1; - } - - if(cache_size>0) - setCpuCacheSizes(cache_size,96*cache_size); - - int m = s; - int n = s; - int p = s; - A a(m,p); a.setRandom(); - B b(p,n); b.setRandom(); - C c(m,n); c.setOnes(); - C rc = c; - - std::cout << "Matrix sizes = " << m << "x" << p << " * " << p << "x" << n << "\n"; - std::ptrdiff_t mc(m), nc(n), kc(p); - internal::computeProductBlockingSizes(kc, mc, nc); - std::cout << "blocking size (mc x kc) = " << mc << " x " << kc << "\n"; - - C r = c; - - // check the parallel product is correct - #if defined EIGEN_HAS_OPENMP - int procs = omp_get_max_threads(); - if(procs>1) - { - #ifdef HAVE_BLAS - blas_gemm(a,b,r); - #else - omp_set_num_threads(1); - r.noalias() += a * b; - omp_set_num_threads(procs); - #endif - c.noalias() += a * b; - if(!r.isApprox(c)) std::cerr << "Warning, your parallel product is crap!\n\n"; - } - #elif defined HAVE_BLAS - blas_gemm(a,b,r); - c.noalias() += a * b; - if(!r.isApprox(c)) std::cerr << "Warning, your product is crap!\n\n"; - #else - gemm(a,b,c); - r.noalias() += a.cast() * b.cast(); - if(!r.isApprox(c)) std::cerr << "Warning, your product is crap!\n\n"; - #endif - - #ifdef HAVE_BLAS - BenchTimer tblas; - c = rc; - BENCH(tblas, tries, rep, blas_gemm(a,b,c)); - std::cout << "blas cpu " << tblas.best(CPU_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/tblas.best(CPU_TIMER))*1e-9 << " GFLOPS \t(" << tblas.total(CPU_TIMER) << "s)\n"; - std::cout << "blas real " << tblas.best(REAL_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/tblas.best(REAL_TIMER))*1e-9 << " GFLOPS \t(" << tblas.total(REAL_TIMER) << "s)\n"; - #endif - - BenchTimer tmt; - c = rc; - BENCH(tmt, tries, rep, gemm(a,b,c)); - std::cout << "eigen cpu " << tmt.best(CPU_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/tmt.best(CPU_TIMER))*1e-9 << " GFLOPS \t(" << tmt.total(CPU_TIMER) << "s)\n"; - std::cout << "eigen real " << tmt.best(REAL_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/tmt.best(REAL_TIMER))*1e-9 << " GFLOPS \t(" << tmt.total(REAL_TIMER) << "s)\n"; - - #ifdef EIGEN_HAS_OPENMP - if(procs>1) - { - BenchTimer tmono; - omp_set_num_threads(1); - Eigen::internal::setNbThreads(1); - c = rc; - BENCH(tmono, tries, rep, gemm(a,b,c)); - std::cout << "eigen mono cpu " << tmono.best(CPU_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/tmono.best(CPU_TIMER))*1e-9 << " GFLOPS \t(" << tmono.total(CPU_TIMER) << "s)\n"; - std::cout << "eigen mono real " << tmono.best(REAL_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/tmono.best(REAL_TIMER))*1e-9 << " GFLOPS \t(" << tmono.total(REAL_TIMER) << "s)\n"; - std::cout << "mt speed up x" << tmono.best(CPU_TIMER) / tmt.best(REAL_TIMER) << " => " << (100.0*tmono.best(CPU_TIMER) / tmt.best(REAL_TIMER))/procs << "%\n"; - } - #endif - - #ifdef DECOUPLED - if((NumTraits::IsComplex) && (NumTraits::IsComplex)) - { - M ar(m,p); ar.setRandom(); - M ai(m,p); ai.setRandom(); - M br(p,n); br.setRandom(); - M bi(p,n); bi.setRandom(); - M cr(m,n); cr.setRandom(); - M ci(m,n); ci.setRandom(); - - BenchTimer t; - BENCH(t, tries, rep, matlab_cplx_cplx(ar,ai,br,bi,cr,ci)); - std::cout << "\"matlab\" cpu " << t.best(CPU_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/t.best(CPU_TIMER))*1e-9 << " GFLOPS \t(" << t.total(CPU_TIMER) << "s)\n"; - std::cout << "\"matlab\" real " << t.best(REAL_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/t.best(REAL_TIMER))*1e-9 << " GFLOPS \t(" << t.total(REAL_TIMER) << "s)\n"; - } - if((!NumTraits::IsComplex) && (NumTraits::IsComplex)) - { - M a(m,p); a.setRandom(); - M br(p,n); br.setRandom(); - M bi(p,n); bi.setRandom(); - M cr(m,n); cr.setRandom(); - M ci(m,n); ci.setRandom(); - - BenchTimer t; - BENCH(t, tries, rep, matlab_real_cplx(a,br,bi,cr,ci)); - std::cout << "\"matlab\" cpu " << t.best(CPU_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/t.best(CPU_TIMER))*1e-9 << " GFLOPS \t(" << t.total(CPU_TIMER) << "s)\n"; - std::cout << "\"matlab\" real " << t.best(REAL_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/t.best(REAL_TIMER))*1e-9 << " GFLOPS \t(" << t.total(REAL_TIMER) << "s)\n"; - } - if((NumTraits::IsComplex) && (!NumTraits::IsComplex)) - { - M ar(m,p); ar.setRandom(); - M ai(m,p); ai.setRandom(); - M b(p,n); b.setRandom(); - M cr(m,n); cr.setRandom(); - M ci(m,n); ci.setRandom(); - - BenchTimer t; - BENCH(t, tries, rep, matlab_cplx_real(ar,ai,b,cr,ci)); - std::cout << "\"matlab\" cpu " << t.best(CPU_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/t.best(CPU_TIMER))*1e-9 << " GFLOPS \t(" << t.total(CPU_TIMER) << "s)\n"; - std::cout << "\"matlab\" real " << t.best(REAL_TIMER)/rep << "s \t" << (double(m)*n*p*rep*2/t.best(REAL_TIMER))*1e-9 << " GFLOPS \t(" << t.total(REAL_TIMER) << "s)\n"; - } - #endif - - return 0; -} - diff --git a/eigen3/bench/bench_multi_compilers.sh b/eigen3/bench/bench_multi_compilers.sh deleted file mode 100644 --- a/eigen3/bench/bench_multi_compilers.sh +++ /dev/null @@ -1,28 +0,0 @@ -#!/bin/bash - -if (($# < 2)); then - echo "Usage: $0 compilerlist.txt benchfile.cpp" -else - -compilerlist=$1 -benchfile=$2 - -g=0 -source $compilerlist - -# for each compiler, compile benchfile and run the benchmark -for (( i=0 ; i /dev/null - echo "" - else - echo "compiler not found: $compiler" - fi -done - -fi diff --git a/eigen3/bench/bench_norm.cpp b/eigen3/bench/bench_norm.cpp deleted file mode 100644 --- a/eigen3/bench/bench_norm.cpp +++ /dev/null @@ -1,345 +0,0 @@ -#include -#include -#include -#include "BenchTimer.h" -using namespace Eigen; -using namespace std; - -template -EIGEN_DONT_INLINE typename T::Scalar sqsumNorm(const T& v) -{ - return v.norm(); -} - -template -EIGEN_DONT_INLINE typename T::Scalar hypotNorm(const T& v) -{ - return v.hypotNorm(); -} - -template -EIGEN_DONT_INLINE typename T::Scalar blueNorm(const T& v) -{ - return v.blueNorm(); -} - -template -EIGEN_DONT_INLINE typename T::Scalar lapackNorm(T& v) -{ - typedef typename T::Scalar Scalar; - int n = v.size(); - Scalar scale = 0; - Scalar ssq = 1; - for (int i=0;i= ax) - { - ssq += internal::abs2(ax/scale); - } - else - { - ssq = Scalar(1) + ssq * internal::abs2(scale/ax); - scale = ax; - } - } - return scale * internal::sqrt(ssq); -} - -template -EIGEN_DONT_INLINE typename T::Scalar twopassNorm(T& v) -{ - typedef typename T::Scalar Scalar; - Scalar s = v.cwise().abs().maxCoeff(); - return s*(v/s).norm(); -} - -template -EIGEN_DONT_INLINE typename T::Scalar bl2passNorm(T& v) -{ - return v.stableNorm(); -} - -template -EIGEN_DONT_INLINE typename T::Scalar divacNorm(T& v) -{ - int n =v.size() / 2; - for (int i=0;i0) - { - for (int i=0;i -EIGEN_DONT_INLINE typename T::Scalar pblueNorm(const T& v) -{ - #ifndef EIGEN_VECTORIZE - return v.blueNorm(); - #else - typedef typename T::Scalar Scalar; - - static int nmax = 0; - static Scalar b1, b2, s1m, s2m, overfl, rbig, relerr; - int n; - - if(nmax <= 0) - { - int nbig, ibeta, it, iemin, iemax, iexp; - Scalar abig, eps; - - nbig = std::numeric_limits::max(); // largest integer - ibeta = std::numeric_limits::radix; //NumTraits::Base; // base for floating-point numbers - it = std::numeric_limits::digits; //NumTraits::Mantissa; // number of base-beta digits in mantissa - iemin = std::numeric_limits::min_exponent; // minimum exponent - iemax = std::numeric_limits::max_exponent; // maximum exponent - rbig = std::numeric_limits::max(); // largest floating-point number - - // Check the basic machine-dependent constants. - if(iemin > 1 - 2*it || 1+it>iemax || (it==2 && ibeta<5) - || (it<=4 && ibeta <= 3 ) || it<2) - { - eigen_assert(false && "the algorithm cannot be guaranteed on this computer"); - } - iexp = -((1-iemin)/2); - b1 = std::pow(ibeta, iexp); // lower boundary of midrange - iexp = (iemax + 1 - it)/2; - b2 = std::pow(ibeta,iexp); // upper boundary of midrange - - iexp = (2-iemin)/2; - s1m = std::pow(ibeta,iexp); // scaling factor for lower range - iexp = - ((iemax+it)/2); - s2m = std::pow(ibeta,iexp); // scaling factor for upper range - - overfl = rbig*s2m; // overfow boundary for abig - eps = std::pow(ibeta, 1-it); - relerr = internal::sqrt(eps); // tolerance for neglecting asml - abig = 1.0/eps - 1.0; - if (Scalar(nbig)>abig) nmax = abig; // largest safe n - else nmax = nbig; - } - - typedef typename internal::packet_traits::type Packet; - const int ps = internal::packet_traits::size; - Packet pasml = internal::pset1(Scalar(0)); - Packet pamed = internal::pset1(Scalar(0)); - Packet pabig = internal::pset1(Scalar(0)); - Packet ps2m = internal::pset1(s2m); - Packet ps1m = internal::pset1(s1m); - Packet pb2 = internal::pset1(b2); - Packet pb1 = internal::pset1(b1); - for(int j=0; j(j)); - Packet ax_s2m = internal::pmul(ax,ps2m); - Packet ax_s1m = internal::pmul(ax,ps1m); - Packet maskBig = internal::plt(pb2,ax); - Packet maskSml = internal::plt(ax,pb1); - -// Packet maskMed = internal::pand(maskSml,maskBig); -// Packet scale = internal::pset1(Scalar(0)); -// scale = internal::por(scale, internal::pand(maskBig,ps2m)); -// scale = internal::por(scale, internal::pand(maskSml,ps1m)); -// scale = internal::por(scale, internal::pandnot(internal::pset1(Scalar(1)),maskMed)); -// ax = internal::pmul(ax,scale); -// ax = internal::pmul(ax,ax); -// pabig = internal::padd(pabig, internal::pand(maskBig, ax)); -// pasml = internal::padd(pasml, internal::pand(maskSml, ax)); -// pamed = internal::padd(pamed, internal::pandnot(ax,maskMed)); - - - pabig = internal::padd(pabig, internal::pand(maskBig, internal::pmul(ax_s2m,ax_s2m))); - pasml = internal::padd(pasml, internal::pand(maskSml, internal::pmul(ax_s1m,ax_s1m))); - pamed = internal::padd(pamed, internal::pandnot(internal::pmul(ax,ax),internal::pand(maskSml,maskBig))); - } - Scalar abig = internal::predux(pabig); - Scalar asml = internal::predux(pasml); - Scalar amed = internal::predux(pamed); - if(abig > Scalar(0)) - { - abig = internal::sqrt(abig); - if(abig > overfl) - { - eigen_assert(false && "overflow"); - return rbig; - } - if(amed > Scalar(0)) - { - abig = abig/s2m; - amed = internal::sqrt(amed); - } - else - { - return abig/s2m; - } - - } - else if(asml > Scalar(0)) - { - if (amed > Scalar(0)) - { - abig = internal::sqrt(amed); - amed = internal::sqrt(asml) / s1m; - } - else - { - return internal::sqrt(asml)/s1m; - } - } - else - { - return internal::sqrt(amed); - } - asml = std::min(abig, amed); - abig = std::max(abig, amed); - if(asml <= abig*relerr) - return abig; - else - return abig * internal::sqrt(Scalar(1) + internal::abs2(asml/abig)); - #endif -} - -#define BENCH_PERF(NRM) { \ - Eigen::BenchTimer tf, td, tcf; tf.reset(); td.reset(); tcf.reset();\ - for (int k=0; k()); - double yd = based * internal::abs(internal::random()); - VectorXf vf = VectorXf::Ones(s) * yf; - VectorXd vd = VectorXd::Ones(s) * yd; - - std::cout << "reference\t" << internal::sqrt(double(s))*yf << "\t" << internal::sqrt(double(s))*yd << "\n"; - std::cout << "sqsumNorm\t" << sqsumNorm(vf) << "\t" << sqsumNorm(vd) << "\n"; - std::cout << "hypotNorm\t" << hypotNorm(vf) << "\t" << hypotNorm(vd) << "\n"; - std::cout << "blueNorm\t" << blueNorm(vf) << "\t" << blueNorm(vd) << "\n"; - std::cout << "pblueNorm\t" << pblueNorm(vf) << "\t" << pblueNorm(vd) << "\n"; - std::cout << "lapackNorm\t" << lapackNorm(vf) << "\t" << lapackNorm(vd) << "\n"; - std::cout << "twopassNorm\t" << twopassNorm(vf) << "\t" << twopassNorm(vd) << "\n"; - std::cout << "bl2passNorm\t" << bl2passNorm(vf) << "\t" << bl2passNorm(vd) << "\n"; -} - -void check_accuracy_var(int ef0, int ef1, int ed0, int ed1, int s) -{ - VectorXf vf(s); - VectorXd vd(s); - for (int i=0; i()) * std::pow(double(10), internal::random(ef0,ef1)); - vd[i] = internal::abs(internal::random()) * std::pow(double(10), internal::random(ed0,ed1)); - } - - //std::cout << "reference\t" << internal::sqrt(double(s))*yf << "\t" << internal::sqrt(double(s))*yd << "\n"; - std::cout << "sqsumNorm\t" << sqsumNorm(vf) << "\t" << sqsumNorm(vd) << "\t" << sqsumNorm(vf.cast()) << "\t" << sqsumNorm(vd.cast()) << "\n"; - std::cout << "hypotNorm\t" << hypotNorm(vf) << "\t" << hypotNorm(vd) << "\t" << hypotNorm(vf.cast()) << "\t" << hypotNorm(vd.cast()) << "\n"; - std::cout << "blueNorm\t" << blueNorm(vf) << "\t" << blueNorm(vd) << "\t" << blueNorm(vf.cast()) << "\t" << blueNorm(vd.cast()) << "\n"; - std::cout << "pblueNorm\t" << pblueNorm(vf) << "\t" << pblueNorm(vd) << "\t" << blueNorm(vf.cast()) << "\t" << blueNorm(vd.cast()) << "\n"; - std::cout << "lapackNorm\t" << lapackNorm(vf) << "\t" << lapackNorm(vd) << "\t" << lapackNorm(vf.cast()) << "\t" << lapackNorm(vd.cast()) << "\n"; - std::cout << "twopassNorm\t" << twopassNorm(vf) << "\t" << twopassNorm(vd) << "\t" << twopassNorm(vf.cast()) << "\t" << twopassNorm(vd.cast()) << "\n"; -// std::cout << "bl2passNorm\t" << bl2passNorm(vf) << "\t" << bl2passNorm(vd) << "\t" << bl2passNorm(vf.cast()) << "\t" << bl2passNorm(vd.cast()) << "\n"; -} - -int main(int argc, char** argv) -{ - int tries = 10; - int iters = 100000; - double y = 1.1345743233455785456788e12 * internal::random(); - VectorXf v = VectorXf::Ones(1024) * y; - -// return 0; - int s = 10000; - double basef_ok = 1.1345743233455785456788e15; - double based_ok = 1.1345743233455785456788e95; - - double basef_under = 1.1345743233455785456788e-27; - double based_under = 1.1345743233455785456788e-303; - - double basef_over = 1.1345743233455785456788e+27; - double based_over = 1.1345743233455785456788e+302; - - std::cout.precision(20); - - std::cerr << "\nNo under/overflow:\n"; - check_accuracy(basef_ok, based_ok, s); - - std::cerr << "\nUnderflow:\n"; - check_accuracy(basef_under, based_under, s); - - std::cerr << "\nOverflow:\n"; - check_accuracy(basef_over, based_over, s); - - std::cerr << "\nVarying (over):\n"; - for (int k=0; k<1; ++k) - { - check_accuracy_var(20,27,190,302,s); - std::cout << "\n"; - } - - std::cerr << "\nVarying (under):\n"; - for (int k=0; k<1; ++k) - { - check_accuracy_var(-27,20,-302,-190,s); - std::cout << "\n"; - } - - std::cout.precision(4); - std::cerr << "Performance (out of cache):\n"; - { - int iters = 1; - VectorXf vf = VectorXf::Random(1024*1024*32) * y; - VectorXd vd = VectorXd::Random(1024*1024*32) * y; - VectorXcf vcf = VectorXcf::Random(1024*1024*32) * y; - BENCH_PERF(sqsumNorm); - BENCH_PERF(blueNorm); -// BENCH_PERF(pblueNorm); -// BENCH_PERF(lapackNorm); -// BENCH_PERF(hypotNorm); -// BENCH_PERF(twopassNorm); - BENCH_PERF(bl2passNorm); - } - - std::cerr << "\nPerformance (in cache):\n"; - { - int iters = 100000; - VectorXf vf = VectorXf::Random(512) * y; - VectorXd vd = VectorXd::Random(512) * y; - VectorXcf vcf = VectorXcf::Random(512) * y; - BENCH_PERF(sqsumNorm); - BENCH_PERF(blueNorm); -// BENCH_PERF(pblueNorm); -// BENCH_PERF(lapackNorm); -// BENCH_PERF(hypotNorm); -// BENCH_PERF(twopassNorm); - BENCH_PERF(bl2passNorm); - } -} diff --git a/eigen3/bench/bench_reverse.cpp b/eigen3/bench/bench_reverse.cpp deleted file mode 100644 --- a/eigen3/bench/bench_reverse.cpp +++ /dev/null @@ -1,84 +0,0 @@ - -#include -#include -#include -using namespace Eigen; - -#ifndef REPEAT -#define REPEAT 100000 -#endif - -#ifndef TRIES -#define TRIES 20 -#endif - -typedef double Scalar; - -template -__attribute__ ((noinline)) void bench_reverse(const MatrixType& m) -{ - int rows = m.rows(); - int cols = m.cols(); - int size = m.size(); - - int repeats = (REPEAT*1000)/size; - MatrixType a = MatrixType::Random(rows,cols); - MatrixType b = MatrixType::Random(rows,cols); - - BenchTimer timerB, timerH, timerV; - - Scalar acc = 0; - int r = internal::random(0,rows-1); - int c = internal::random(0,cols-1); - for (int t=0; t0; ++i) - { - bench_reverse(Matrix(dynsizes[i],dynsizes[i])); - bench_reverse(Matrix(dynsizes[i]*dynsizes[i])); - } -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); -// bench_reverse(Matrix()); - return 0; -} - diff --git a/eigen3/bench/bench_sum.cpp b/eigen3/bench/bench_sum.cpp deleted file mode 100644 --- a/eigen3/bench/bench_sum.cpp +++ /dev/null @@ -1,18 +0,0 @@ -#include -#include -using namespace Eigen; -using namespace std; - -int main() -{ - typedef Matrix Vec; - Vec v(SIZE); - v.setZero(); - v[0] = 1; - v[1] = 2; - for(int i = 0; i < 1000000; i++) - { - v.coeffRef(0) += v.sum() * SCALAR(1e-20); - } - cout << v.sum() << endl; -} diff --git a/eigen3/bench/bench_unrolling b/eigen3/bench/bench_unrolling deleted file mode 100644 --- a/eigen3/bench/bench_unrolling +++ /dev/null @@ -1,12 +0,0 @@ -#!/bin/bash - -# gcc : CXX="g++ -finline-limit=10000 -ftemplate-depth-2000 --param max-inline-recursive-depth=2000" -# icc : CXX="icpc -fast -no-inline-max-size -fno-exceptions" -CXX=${CXX-g++ -finline-limit=10000 -ftemplate-depth-2000 --param max-inline-recursive-depth=2000} # default value - -for ((i=1; i<16; ++i)); do - echo "Matrix size: $i x $i :" - $CXX -O3 -I.. -DNDEBUG benchmark.cpp -DMATSIZE=$i -DEIGEN_UNROLLING_LIMIT=400 -o benchmark && time ./benchmark >/dev/null - $CXX -O3 -I.. -DNDEBUG -finline-limit=10000 benchmark.cpp -DMATSIZE=$i -DEIGEN_DONT_USE_UNROLLED_LOOPS=1 -o benchmark && time ./benchmark >/dev/null - echo " " -done diff --git a/eigen3/bench/benchmark.cpp b/eigen3/bench/benchmark.cpp deleted file mode 100644 --- a/eigen3/bench/benchmark.cpp +++ /dev/null @@ -1,39 +0,0 @@ -// g++ -O3 -DNDEBUG -DMATSIZE= benchmark.cpp -o benchmark && time ./benchmark - -#include - -#include - -#ifndef MATSIZE -#define MATSIZE 3 -#endif - -using namespace std; -using namespace Eigen; - -#ifndef REPEAT -#define REPEAT 40000000 -#endif - -#ifndef SCALAR -#define SCALAR double -#endif - -int main(int argc, char *argv[]) -{ - Matrix I = Matrix::Ones(); - Matrix m; - for(int i = 0; i < MATSIZE; i++) - for(int j = 0; j < MATSIZE; j++) - { - m(i,j) = (i+MATSIZE*j); - } - asm("#begin"); - for(int a = 0; a < REPEAT; a++) - { - m = Matrix::Ones() + 0.00005 * (m + (m*m)); - } - asm("#end"); - cout << m << endl; - return 0; -} diff --git a/eigen3/bench/benchmarkSlice.cpp b/eigen3/bench/benchmarkSlice.cpp deleted file mode 100644 --- a/eigen3/bench/benchmarkSlice.cpp +++ /dev/null @@ -1,38 +0,0 @@ -// g++ -O3 -DNDEBUG benchmarkX.cpp -o benchmarkX && time ./benchmarkX - -#include - -#include - -using namespace std; -using namespace Eigen; - -#ifndef REPEAT -#define REPEAT 10000 -#endif - -#ifndef SCALAR -#define SCALAR float -#endif - -int main(int argc, char *argv[]) -{ - typedef Matrix Mat; - Mat m(100, 100); - m.setRandom(); - - for(int a = 0; a < REPEAT; a++) - { - int r, c, nr, nc; - r = Eigen::internal::random(0,10); - c = Eigen::internal::random(0,10); - nr = Eigen::internal::random(50,80); - nc = Eigen::internal::random(50,80); - m.block(r,c,nr,nc) += Mat::Ones(nr,nc); - m.block(r,c,nr,nc) *= SCALAR(10); - m.block(r,c,nr,nc) -= Mat::constant(nr,nc,10); - m.block(r,c,nr,nc) /= SCALAR(10); - } - cout << m[0] << endl; - return 0; -} diff --git a/eigen3/bench/benchmarkX.cpp b/eigen3/bench/benchmarkX.cpp deleted file mode 100644 --- a/eigen3/bench/benchmarkX.cpp +++ /dev/null @@ -1,36 +0,0 @@ -// g++ -fopenmp -I .. -O3 -DNDEBUG -finline-limit=1000 benchmarkX.cpp -o b && time ./b - -#include - -#include - -using namespace std; -using namespace Eigen; - -#ifndef MATTYPE -#define MATTYPE MatrixXLd -#endif - -#ifndef MATSIZE -#define MATSIZE 400 -#endif - -#ifndef REPEAT -#define REPEAT 100 -#endif - -int main(int argc, char *argv[]) -{ - MATTYPE I = MATTYPE::Ones(MATSIZE,MATSIZE); - MATTYPE m(MATSIZE,MATSIZE); - for(int i = 0; i < MATSIZE; i++) for(int j = 0; j < MATSIZE; j++) - { - m(i,j) = (i+j+1)/(MATSIZE*MATSIZE); - } - for(int a = 0; a < REPEAT; a++) - { - m = I + 0.0001 * (m + m*m); - } - cout << m(0,0) << endl; - return 0; -} diff --git a/eigen3/bench/benchmarkXcwise.cpp b/eigen3/bench/benchmarkXcwise.cpp deleted file mode 100644 --- a/eigen3/bench/benchmarkXcwise.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// g++ -O3 -DNDEBUG benchmarkX.cpp -o benchmarkX && time ./benchmarkX - -#include -#include - -using namespace std; -using namespace Eigen; - -#ifndef VECTYPE -#define VECTYPE VectorXLd -#endif - -#ifndef VECSIZE -#define VECSIZE 1000000 -#endif - -#ifndef REPEAT -#define REPEAT 1000 -#endif - -int main(int argc, char *argv[]) -{ - VECTYPE I = VECTYPE::Ones(VECSIZE); - VECTYPE m(VECSIZE,1); - for(int i = 0; i < VECSIZE; i++) - { - m[i] = 0.1 * i/VECSIZE; - } - for(int a = 0; a < REPEAT; a++) - { - m = VECTYPE::Ones(VECSIZE) + 0.00005 * (m.cwise().square() + m/4); - } - cout << m[0] << endl; - return 0; -} diff --git a/eigen3/bench/benchmark_suite b/eigen3/bench/benchmark_suite deleted file mode 100644 --- a/eigen3/bench/benchmark_suite +++ /dev/null @@ -1,18 +0,0 @@ -#!/bin/bash -CXX=${CXX-g++} # default value unless caller has defined CXX -echo "Fixed size 3x3, column-major, -DNDEBUG" -$CXX -O3 -I .. -DNDEBUG benchmark.cpp -o benchmark && time ./benchmark >/dev/null -echo "Fixed size 3x3, column-major, with asserts" -$CXX -O3 -I .. benchmark.cpp -o benchmark && time ./benchmark >/dev/null -echo "Fixed size 3x3, row-major, -DNDEBUG" -$CXX -O3 -I .. -DEIGEN_DEFAULT_TO_ROW_MAJOR -DNDEBUG benchmark.cpp -o benchmark && time ./benchmark >/dev/null -echo "Fixed size 3x3, row-major, with asserts" -$CXX -O3 -I .. -DEIGEN_DEFAULT_TO_ROW_MAJOR benchmark.cpp -o benchmark && time ./benchmark >/dev/null -echo "Dynamic size 20x20, column-major, -DNDEBUG" -$CXX -O3 -I .. -DNDEBUG benchmarkX.cpp -o benchmarkX && time ./benchmarkX >/dev/null -echo "Dynamic size 20x20, column-major, with asserts" -$CXX -O3 -I .. benchmarkX.cpp -o benchmarkX && time ./benchmarkX >/dev/null -echo "Dynamic size 20x20, row-major, -DNDEBUG" -$CXX -O3 -I .. -DEIGEN_DEFAULT_TO_ROW_MAJOR -DNDEBUG benchmarkX.cpp -o benchmarkX && time ./benchmarkX >/dev/null -echo "Dynamic size 20x20, row-major, with asserts" -$CXX -O3 -I .. -DEIGEN_DEFAULT_TO_ROW_MAJOR benchmarkX.cpp -o benchmarkX && time ./benchmarkX >/dev/null diff --git a/eigen3/bench/btl/CMakeLists.txt b/eigen3/bench/btl/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/CMakeLists.txt +++ /dev/null @@ -1,104 +0,0 @@ -PROJECT(BTL) - -CMAKE_MINIMUM_REQUIRED(VERSION 2.6.2) - -set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake ${Eigen_SOURCE_DIR}/cmake) -include(MacroOptionalAddSubdirectory) - -OPTION(BTL_NOVEC "Disable SSE/Altivec optimizations when possible" OFF) - -SET(CMAKE_INCLUDE_CURRENT_DIR ON) - -string(REGEX MATCH icpc IS_ICPC ${CMAKE_CXX_COMPILER}) -IF(CMAKE_COMPILER_IS_GNUCXX OR IS_ICPC) - SET(CMAKE_CXX_FLAGS "-g0 -O3 -DNDEBUG") - SET(CMAKE_Fortran_FLAGS "-g0 -O3 -DNDEBUG") - IF(NOT BTL_NOVEC) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse2") - SET(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -msse2") - ELSE(NOT BTL_NOVEC) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEIGEN_DONT_VECTORIZE") - ENDIF(NOT BTL_NOVEC) -ENDIF(CMAKE_COMPILER_IS_GNUCXX OR IS_ICPC) - -IF(MSVC) - SET(CMAKE_CXX_FLAGS " /O2 /Ot /GL /fp:fast -DNDEBUG") -# SET(CMAKE_Fortran_FLAGS "-g0 -O3 -DNDEBUG") - IF(NOT BTL_NOVEC) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:SSE2") - ELSE(NOT BTL_NOVEC) - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEIGEN_DONT_VECTORIZE") - ENDIF(NOT BTL_NOVEC) -ENDIF(MSVC) - -if(IS_ICPC) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fast") - set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fast") -endif(IS_ICPC) - -include_directories( - ${PROJECT_SOURCE_DIR}/actions - ${PROJECT_SOURCE_DIR}/generic_bench - ${PROJECT_SOURCE_DIR}/generic_bench/utils - ${PROJECT_SOURCE_DIR}/libs/STL) - -# find_package(MKL) -# if (MKL_FOUND) -# add_definitions(-DHAVE_MKL) -# set(DEFAULT_LIBRARIES ${MKL_LIBRARIES}) -# endif (MKL_FOUND) - -MACRO(BTL_ADD_BENCH targetname) - - foreach(_current_var ${ARGN}) - set(_last_var ${_current_var}) - endforeach(_current_var) - - set(_sources ${ARGN}) - list(LENGTH _sources _argn_length) - - list(REMOVE_ITEM _sources ON OFF TRUE FALSE) - - list(LENGTH _sources _src_length) - - if (${_argn_length} EQUAL ${_src_length}) - set(_last_var ON) - endif (${_argn_length} EQUAL ${_src_length}) - - OPTION(BUILD_${targetname} "Build benchmark ${targetname}" ${_last_var}) - - IF(BUILD_${targetname}) - ADD_EXECUTABLE(${targetname} ${_sources}) - ADD_TEST(${targetname} "${targetname}") - target_link_libraries(${targetname} ${DEFAULT_LIBRARIES} rt) - ENDIF(BUILD_${targetname}) - -ENDMACRO(BTL_ADD_BENCH) - -macro(btl_add_target_property target prop value) - - if(BUILD_${target}) - get_target_property(previous ${target} ${prop}) - if(NOT previous) - set(previous "") - endif() - set_target_properties(${target} PROPERTIES ${prop} "${previous} ${value}") - endif() - -endmacro(btl_add_target_property) - -ENABLE_TESTING() - -add_subdirectory(libs/eigen3) -add_subdirectory(libs/eigen2) -add_subdirectory(libs/BLAS) -add_subdirectory(libs/ublas) -add_subdirectory(libs/gmm) -add_subdirectory(libs/mtl4) -add_subdirectory(libs/blitz) -add_subdirectory(libs/tvmet) -add_subdirectory(libs/STL) - -add_subdirectory(data) - - diff --git a/eigen3/bench/btl/COPYING b/eigen3/bench/btl/COPYING deleted file mode 100644 --- a/eigen3/bench/btl/COPYING +++ /dev/null @@ -1,340 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 Free Software Foundation, Inc. - 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change free -software--to make sure the software is free for all its users. This -General Public License applies to most of the Free Software -Foundation's software and to any other program whose authors commit to -using it. (Some other Free Software Foundation software is covered by -the GNU Library General Public License instead.) You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -this service if you wish), that you receive source code or can get it -if you want it, that you can change the software or use pieces of it -in new free programs; and that you know you can do these things. - - To protect your rights, we need to make restrictions that forbid -anyone to deny you these rights or to ask you to surrender the rights. -These restrictions translate to certain responsibilities for you if you -distribute copies of the software, or if you modify it. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must give the recipients all the rights that -you have. You must make sure that they, too, receive or can get the -source code. And you must show them these terms so they know their -rights. - - We protect your rights with two steps: (1) copyright the software, and -(2) offer you this license which gives you legal permission to copy, -distribute and/or modify the software. - - Also, for each author's protection and ours, we want to make certain -that everyone understands that there is no warranty for this free -software. If the software is modified by someone else and passed on, we -want its recipients to know that what they have is not the original, so -that any problems introduced by others will not reflect on the original -authors' reputations. - - Finally, any free program is threatened constantly by software -patents. We wish to avoid the danger that redistributors of a free -program will individually obtain patent licenses, in effect making the -program proprietary. To prevent this, we have made it clear that any -patent must be licensed for everyone's free use or not licensed at all. - - The precise terms and conditions for copying, distribution and -modification follow. - - GNU GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License applies to any program or other work which contains -a notice placed by the copyright holder saying it may be distributed -under the terms of this General Public License. The "Program", below, -refers to any such program or work, and a "work based on the Program" -means either the Program or any derivative work under copyright law: -that is to say, a work containing the Program or a portion of it, -either verbatim or with modifications and/or translated into another -language. (Hereinafter, translation is included without limitation in -the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running the Program is not restricted, and the output from the Program -is covered only if its contents constitute a work based on the -Program (independent of having been made by running the Program). -Whether that is true depends on what the Program does. - - 1. You may copy and distribute verbatim copies of the Program's -source code as you receive it, in any medium, provided that you -conspicuously and appropriately publish on each copy an appropriate -copyright notice and disclaimer of warranty; keep intact all the -notices that refer to this License and to the absence of any warranty; -and give any other recipients of the Program a copy of this License -along with the Program. - -You may charge a fee for the physical act of transferring a copy, and -you may at your option offer warranty protection in exchange for a fee. - - 2. You may modify your copy or copies of the Program or any portion -of it, thus forming a work based on the Program, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) You must cause the modified files to carry prominent notices - stating that you changed the files and the date of any change. - - b) You must cause any work that you distribute or publish, that in - whole or in part contains or is derived from the Program or any - part thereof, to be licensed as a whole at no charge to all third - parties under the terms of this License. - - c) If the modified program normally reads commands interactively - when run, you must cause it, when started running for such - interactive use in the most ordinary way, to print or display an - announcement including an appropriate copyright notice and a - notice that there is no warranty (or else, saying that you provide - a warranty) and that users may redistribute the program under - these conditions, and telling the user how to view a copy of this - License. (Exception: if the Program itself is interactive but - does not normally print such an announcement, your work based on - the Program is not required to print an announcement.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Program, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Program, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Program. - -In addition, mere aggregation of another work not based on the Program -with the Program (or with a work based on the Program) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may copy and distribute the Program (or a work based on it, -under Section 2) in object code or executable form under the terms of -Sections 1 and 2 above provided that you also do one of the following: - - a) Accompany it with the complete corresponding machine-readable - source code, which must be distributed under the terms of Sections - 1 and 2 above on a medium customarily used for software interchange; or, - - b) Accompany it with a written offer, valid for at least three - years, to give any third party, for a charge no more than your - cost of physically performing source distribution, a complete - machine-readable copy of the corresponding source code, to be - distributed under the terms of Sections 1 and 2 above on a medium - customarily used for software interchange; or, - - c) Accompany it with the information you received as to the offer - to distribute corresponding source code. (This alternative is - allowed only for noncommercial distribution and only if you - received the program in object code or executable form with such - an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for -making modifications to it. For an executable work, complete source -code means all the source code for all modules it contains, plus any -associated interface definition files, plus the scripts used to -control compilation and installation of the executable. However, as a -special exception, the source code distributed need not include -anything that is normally distributed (in either source or binary -form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component -itself accompanies the executable. - -If distribution of executable or object code is made by offering -access to copy from a designated place, then offering equivalent -access to copy the source code from the same place counts as -distribution of the source code, even though third parties are not -compelled to copy the source along with the object code. - - 4. You may not copy, modify, sublicense, or distribute the Program -except as expressly provided under this License. Any attempt -otherwise to copy, modify, sublicense or distribute the Program is -void, and will automatically terminate your rights under this License. -However, parties who have received copies, or rights, from you under -this License will not have their licenses terminated so long as such -parties remain in full compliance. - - 5. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Program or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Program (or any work based on the -Program), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - - 6. Each time you redistribute the Program (or any work based on the -Program), the recipient automatically receives a license from the -original licensor to copy, distribute or modify the Program subject to -these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties to -this License. - - 7. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Program at all. For example, if a patent -license would not permit royalty-free redistribution of the Program by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system, which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 8. If the distribution and/or use of the Program is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Program under this License -may add an explicit geographical distribution limitation excluding -those countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 9. The Free Software Foundation may publish revised and/or new versions -of the General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - -Each version is given a distinguishing version number. If the Program -specifies a version number of this License which applies to it and "any -later version", you have the option of following the terms and conditions -either of that version or of any later version published by the Free -Software Foundation. If the Program does not specify a version number of -this License, you may choose any version ever published by the Free Software -Foundation. - - 10. If you wish to incorporate parts of the Program into other free -programs whose distribution conditions are different, write to the author -to ask for permission. For software which is copyrighted by the Free -Software Foundation, write to the Free Software Foundation; we sometimes -make exceptions for this. Our decision will be guided by the two goals -of preserving the free status of all derivatives of our free software and -of promoting the sharing and reuse of software generally. - - NO WARRANTY - - 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, -REPAIR OR CORRECTION. - - 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - - -Also add information on how to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this -when it starts in an interactive mode: - - Gnomovision version 69, Copyright (C) year name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may -be called something other than `show w' and `show c'; they could even be -mouse-clicks or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the program, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the program - `Gnomovision' (which makes passes at compilers) written by James Hacker. - - , 1 April 1989 - Ty Coon, President of Vice - -This General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may -consider it more useful to permit linking proprietary applications with the -library. If this is what you want to do, use the GNU Library General -Public License instead of this License. diff --git a/eigen3/bench/btl/README b/eigen3/bench/btl/README deleted file mode 100644 --- a/eigen3/bench/btl/README +++ /dev/null @@ -1,154 +0,0 @@ -Bench Template Library - -**************************************** -Introduction : - -The aim of this project is to compare the performance -of available numerical libraries. The code is designed -as generic and modular as possible. Thus, adding new -numerical libraries or new numerical tests should -require minimal effort. - - -***************************************** - -Installation : - -BTL uses cmake / ctest: - -1 - create a build directory: - - $ mkdir build - $ cd build - -2 - configure: - - $ ccmake .. - -3 - run the bench using ctest: - - $ ctest -V - -You can run the benchmarks only on libraries matching a given regular expression: - ctest -V -R -For instance: - ctest -V -R eigen2 - -You can also select a given set of actions defining the environment variable BTL_CONFIG this way: - BTL_CONFIG="-a action1{:action2}*" ctest -V -An exemple: - BTL_CONFIG="-a axpy:vector_matrix:trisolve:ata" ctest -V -R eigen2 - -Finally, if bench results already exist (the bench*.dat files) then they merges by keeping the best for each matrix size. If you want to overwrite the previous ones you can simply add the "--overwrite" option: - BTL_CONFIG="-a axpy:vector_matrix:trisolve:ata --overwrite" ctest -V -R eigen2 - -4 : Analyze the result. different data files (.dat) are produced in each libs directories. - If gnuplot is available, choose a directory name in the data directory to store the results and type: - $ cd data - $ mkdir my_directory - $ cp ../libs/*/*.dat my_directory - Build the data utilities in this (data) directory - make - Then you can look the raw data, - go_mean my_directory - or smooth the data first : - smooth_all.sh my_directory - go_mean my_directory_smooth - - -************************************************* - -Files and directories : - - generic_bench : all the bench sources common to all libraries - - actions : sources for different action wrappers (axpy, matrix-matrix product) to be tested. - - libs/* : bench sources specific to each tested libraries. - - machine_dep : directory used to store machine specific Makefile.in - - data : directory used to store gnuplot scripts and data analysis utilities - -************************************************** - -Principles : the code modularity is achieved by defining two concepts : - - ****** Action concept : This is a class defining which kind - of test must be performed (e.g. a matrix_vector_product). - An Action should define the following methods : - - *** Ctor using the size of the problem (matrix or vector size) as an argument - Action action(size); - *** initialize : this method initialize the calculation (e.g. initialize the matrices and vectors arguments) - action.initialize(); - *** calculate : this method actually launch the calculation to be benchmarked - action.calculate; - *** nb_op_base() : this method returns the complexity of the calculate method (allowing the mflops evaluation) - *** name() : this method returns the name of the action (std::string) - - ****** Interface concept : This is a class or namespace defining how to use a given library and - its specific containers (matrix and vector). Up to now an interface should following types - - *** real_type : kind of float to be used (float or double) - *** stl_vector : must correspond to std::vector - *** stl_matrix : must correspond to std::vector - *** gene_vector : the vector type for this interface --> e.g. (real_type *) for the C_interface - *** gene_matrix : the matrix type for this interface --> e.g. (gene_vector *) for the C_interface - - + the following common methods - - *** free_matrix(gene_matrix & A, int N) dealocation of a N sized gene_matrix A - *** free_vector(gene_vector & B) dealocation of a N sized gene_vector B - *** matrix_from_stl(gene_matrix & A, stl_matrix & A_stl) copy the content of an stl_matrix A_stl into a gene_matrix A. - The allocation of A is done in this function. - *** vector_to_stl(gene_vector & B, stl_vector & B_stl) copy the content of an stl_vector B_stl into a gene_vector B. - The allocation of B is done in this function. - *** matrix_to_stl(gene_matrix & A, stl_matrix & A_stl) copy the content of an gene_matrix A into an stl_matrix A_stl. - The size of A_STL must corresponds to the size of A. - *** vector_to_stl(gene_vector & A, stl_vector & A_stl) copy the content of an gene_vector A into an stl_vector A_stl. - The size of B_STL must corresponds to the size of B. - *** copy_matrix(gene_matrix & source, gene_matrix & cible, int N) : copy the content of source in cible. Both source - and cible must be sized NxN. - *** copy_vector(gene_vector & source, gene_vector & cible, int N) : copy the content of source in cible. Both source - and cible must be sized N. - - and the following method corresponding to the action one wants to be benchmarked : - - *** matrix_vector_product(const gene_matrix & A, const gene_vector & B, gene_vector & X, int N) - *** matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N) - *** ata_product(const gene_matrix & A, gene_matrix & X, int N) - *** aat_product(const gene_matrix & A, gene_matrix & X, int N) - *** axpy(real coef, const gene_vector & X, gene_vector & Y, int N) - - The bench algorithm (generic_bench/bench.hh) is templated with an action itself templated with - an interface. A typical main.cpp source stored in a given library directory libs/A_LIB - looks like : - - bench< AN_ACTION < AN_INTERFACE > >( 10 , 1000 , 50 ) ; - - this function will produce XY data file containing measured mflops as a function of the size for 50 - sizes between 10 and 10000. - - This algorithm can be adapted by providing a given Perf_Analyzer object which determines how the time - measurements must be done. For example, the X86_Perf_Analyzer use the asm rdtsc function and provides - a very fast and accurate (but less portable) timing method. The default is the Portable_Perf_Analyzer - so - - bench< AN_ACTION < AN_INTERFACE > >( 10 , 1000 , 50 ) ; - - is equivalent to - - bench< Portable_Perf_Analyzer,AN_ACTION < AN_INTERFACE > >( 10 , 1000 , 50 ) ; - - If your system supports it we suggest to use a mixed implementation (X86_perf_Analyzer+Portable_Perf_Analyzer). - replace - bench(size_min,size_max,nb_point); - with - bench(size_min,size_max,nb_point); - in generic/bench.hh - -. - - - diff --git a/eigen3/bench/btl/actions/action_aat_product.hh b/eigen3/bench/btl/actions/action_aat_product.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_aat_product.hh +++ /dev/null @@ -1,145 +0,0 @@ -//===================================================== -// File : action_aat_product.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_AAT_PRODUCT -#define ACTION_AAT_PRODUCT -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_aat_product { - -public : - - // Ctor - - Action_aat_product( int size ):_size(size) - { - MESSAGE("Action_aat_product Ctor"); - - // STL matrix and vector initialization - - init_matrix(A_stl,_size); - init_matrix(X_stl,_size); - init_matrix(resu_stl,_size); - - // generic matrix and vector initialization - - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(X_ref,X_stl); - - Interface::matrix_from_stl(A,A_stl); - Interface::matrix_from_stl(X,X_stl); - - } - - // invalidate copy ctor - - Action_aat_product( const Action_aat_product & ) - { - INFOS("illegal call to Action_aat_product Copy Ctor"); - exit(0); - } - - // Dtor - - ~Action_aat_product( void ){ - - MESSAGE("Action_aat_product Dtor"); - - // deallocation - - Interface::free_matrix(A,_size); - Interface::free_matrix(X,_size); - - Interface::free_matrix(A_ref,_size); - Interface::free_matrix(X_ref,_size); - - } - - // action name - - static inline std::string name( void ) - { - return "aat_"+Interface::name(); - } - - double nb_op_base( void ){ - return double(_size)*double(_size)*double(_size); - } - - inline void initialize( void ){ - - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_matrix(X_ref,X,_size); - - } - - inline void calculate( void ) { - - Interface::aat_product(A,X,_size); - - } - - void check_result( void ){ - if (_size>128) return; - // calculation check - - Interface::matrix_to_stl(X,resu_stl); - - STL_interface::aat_product(A_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-6){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(1); - } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_matrix X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_matrix X; - - - int _size; - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_ata_product.hh b/eigen3/bench/btl/actions/action_ata_product.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_ata_product.hh +++ /dev/null @@ -1,145 +0,0 @@ -//===================================================== -// File : action_ata_product.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_ATA_PRODUCT -#define ACTION_ATA_PRODUCT -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_ata_product { - -public : - - // Ctor - - Action_ata_product( int size ):_size(size) - { - MESSAGE("Action_ata_product Ctor"); - - // STL matrix and vector initialization - - init_matrix(A_stl,_size); - init_matrix(X_stl,_size); - init_matrix(resu_stl,_size); - - // generic matrix and vector initialization - - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(X_ref,X_stl); - - Interface::matrix_from_stl(A,A_stl); - Interface::matrix_from_stl(X,X_stl); - - } - - // invalidate copy ctor - - Action_ata_product( const Action_ata_product & ) - { - INFOS("illegal call to Action_ata_product Copy Ctor"); - exit(0); - } - - // Dtor - - ~Action_ata_product( void ){ - - MESSAGE("Action_ata_product Dtor"); - - // deallocation - - Interface::free_matrix(A,_size); - Interface::free_matrix(X,_size); - - Interface::free_matrix(A_ref,_size); - Interface::free_matrix(X_ref,_size); - - } - - // action name - - static inline std::string name( void ) - { - return "ata_"+Interface::name(); - } - - double nb_op_base( void ){ - return 2.0*_size*_size*_size; - } - - inline void initialize( void ){ - - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_matrix(X_ref,X,_size); - - } - - inline void calculate( void ) { - - Interface::ata_product(A,X,_size); - - } - - void check_result( void ){ - if (_size>128) return; - // calculation check - - Interface::matrix_to_stl(X,resu_stl); - - STL_interface::ata_product(A_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-6){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(1); - } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_matrix X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_matrix X; - - - int _size; - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_atv_product.hh b/eigen3/bench/btl/actions/action_atv_product.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_atv_product.hh +++ /dev/null @@ -1,134 +0,0 @@ -//===================================================== -// File : action_atv_product.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_ATV_PRODUCT -#define ACTION_ATV_PRODUCT -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_atv_product { - -public : - - Action_atv_product( int size ) : _size(size) - { - MESSAGE("Action_atv_product Ctor"); - - // STL matrix and vector initialization - - init_matrix(A_stl,_size); - init_vector(B_stl,_size); - init_vector(X_stl,_size); - init_vector(resu_stl,_size); - - // generic matrix and vector initialization - - Interface::matrix_from_stl(A_ref,A_stl); - Interface::vector_from_stl(B_ref,B_stl); - Interface::vector_from_stl(X_ref,X_stl); - - Interface::matrix_from_stl(A,A_stl); - Interface::vector_from_stl(B,B_stl); - Interface::vector_from_stl(X,X_stl); - } - - // invalidate copy ctor - Action_atv_product( const Action_atv_product & ) - { - INFOS("illegal call to Action_atv_product Copy Ctor"); - exit(1); - } - - ~Action_atv_product( void ) - { - MESSAGE("Action_atv_product Dtor"); - - Interface::free_matrix(A,_size); - Interface::free_vector(B); - Interface::free_vector(X); - - Interface::free_matrix(A_ref,_size); - Interface::free_vector(B_ref); - Interface::free_vector(X_ref); - } - - static inline std::string name() { return "atv_" + Interface::name(); } - - double nb_op_base( void ) { return 2.0*_size*_size; } - - inline void initialize( void ){ - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_vector(B_ref,B,_size); - Interface::copy_vector(X_ref,X,_size); - } - - BTL_DONT_INLINE void calculate( void ) { - BTL_ASM_COMMENT("begin atv"); - Interface::atv_product(A,B,X,_size); - BTL_ASM_COMMENT("end atv"); - } - - void check_result( void ) - { - if (_size>128) return; - Interface::vector_to_stl(X,resu_stl); - - STL_interface::atv_product(A_stl,B_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-6){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(1); - } - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_vector B_stl; - typename Interface::stl_vector X_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_vector B_ref; - typename Interface::gene_vector X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_vector B; - typename Interface::gene_vector X; - - - int _size; - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_axpby.hh b/eigen3/bench/btl/actions/action_axpby.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_axpby.hh +++ /dev/null @@ -1,127 +0,0 @@ -//===================================================== -// File : action_axpby.hh -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_AXPBY -#define ACTION_AXPBY -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_axpby { - -public : - - // Ctor - Action_axpby( int size ):_size(size),_alpha(0.5),_beta(0.95) - { - MESSAGE("Action_axpby Ctor"); - - // STL vector initialization - init_vector(X_stl,_size); - init_vector(Y_stl,_size); - init_vector(resu_stl,_size); - - // generic matrix and vector initialization - Interface::vector_from_stl(X_ref,X_stl); - Interface::vector_from_stl(Y_ref,Y_stl); - - Interface::vector_from_stl(X,X_stl); - Interface::vector_from_stl(Y,Y_stl); - } - - // invalidate copy ctor - Action_axpby( const Action_axpby & ) - { - INFOS("illegal call to Action_axpby Copy Ctor"); - exit(1); - } - - // Dtor - ~Action_axpby( void ){ - MESSAGE("Action_axpby Dtor"); - - // deallocation - Interface::free_vector(X_ref); - Interface::free_vector(Y_ref); - - Interface::free_vector(X); - Interface::free_vector(Y); - } - - // action name - static inline std::string name( void ) - { - return "axpby_"+Interface::name(); - } - - double nb_op_base( void ){ - return 3.0*_size; - } - - inline void initialize( void ){ - Interface::copy_vector(X_ref,X,_size); - Interface::copy_vector(Y_ref,Y,_size); - } - - inline void calculate( void ) { - BTL_ASM_COMMENT("mybegin axpby"); - Interface::axpby(_alpha,X,_beta,Y,_size); - BTL_ASM_COMMENT("myend axpby"); - } - - void check_result( void ){ - if (_size>128) return; - // calculation check - Interface::vector_to_stl(Y,resu_stl); - - STL_interface::axpby(_alpha,X_stl,_beta,Y_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(Y_stl,resu_stl); - - if (error>1.e-6){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(2); - } - } - -private : - - typename Interface::stl_vector X_stl; - typename Interface::stl_vector Y_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_vector X_ref; - typename Interface::gene_vector Y_ref; - - typename Interface::gene_vector X; - typename Interface::gene_vector Y; - - typename Interface::real_type _alpha; - typename Interface::real_type _beta; - - int _size; -}; - -#endif diff --git a/eigen3/bench/btl/actions/action_axpy.hh b/eigen3/bench/btl/actions/action_axpy.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_axpy.hh +++ /dev/null @@ -1,139 +0,0 @@ -//===================================================== -// File : action_axpy.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_AXPY -#define ACTION_AXPY -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_axpy { - -public : - - // Ctor - - Action_axpy( int size ):_size(size),_coef(1.0) - { - MESSAGE("Action_axpy Ctor"); - - // STL vector initialization - - init_vector(X_stl,_size); - init_vector(Y_stl,_size); - init_vector(resu_stl,_size); - - // generic matrix and vector initialization - - Interface::vector_from_stl(X_ref,X_stl); - Interface::vector_from_stl(Y_ref,Y_stl); - - Interface::vector_from_stl(X,X_stl); - Interface::vector_from_stl(Y,Y_stl); - - - } - - // invalidate copy ctor - - Action_axpy( const Action_axpy & ) - { - INFOS("illegal call to Action_axpy Copy Ctor"); - exit(1); - } - - // Dtor - - ~Action_axpy( void ){ - - MESSAGE("Action_axpy Dtor"); - - // deallocation - - Interface::free_vector(X_ref); - Interface::free_vector(Y_ref); - - Interface::free_vector(X); - Interface::free_vector(Y); - } - - // action name - - static inline std::string name( void ) - { - return "axpy_"+Interface::name(); - } - - double nb_op_base( void ){ - return 2.0*_size; - } - - inline void initialize( void ){ - Interface::copy_vector(X_ref,X,_size); - Interface::copy_vector(Y_ref,Y,_size); - } - - inline void calculate( void ) { - BTL_ASM_COMMENT("mybegin axpy"); - Interface::axpy(_coef,X,Y,_size); - BTL_ASM_COMMENT("myend axpy"); - } - - void check_result( void ){ - if (_size>128) return; - // calculation check - - Interface::vector_to_stl(Y,resu_stl); - - STL_interface::axpy(_coef,X_stl,Y_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(Y_stl,resu_stl); - - if (error>1.e-6){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(0); - } - - } - -private : - - typename Interface::stl_vector X_stl; - typename Interface::stl_vector Y_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_vector X_ref; - typename Interface::gene_vector Y_ref; - - typename Interface::gene_vector X; - typename Interface::gene_vector Y; - - typename Interface::real_type _coef; - - int _size; -}; - -#endif diff --git a/eigen3/bench/btl/actions/action_cholesky.hh b/eigen3/bench/btl/actions/action_cholesky.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_cholesky.hh +++ /dev/null @@ -1,128 +0,0 @@ -//===================================================== -// File : action_cholesky.hh -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_CHOLESKY -#define ACTION_CHOLESKY -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_cholesky { - -public : - - // Ctor - - Action_cholesky( int size ):_size(size) - { - MESSAGE("Action_cholesky Ctor"); - - // STL mat/vec initialization - init_matrix_symm(X_stl,_size); - init_matrix(C_stl,_size); - - // make sure X is invertible - for (int i=0; i<_size; ++i) - X_stl[i][i] = std::abs(X_stl[i][i]) * 1e2 + 100; - - // generic matrix and vector initialization - Interface::matrix_from_stl(X_ref,X_stl); - Interface::matrix_from_stl(X,X_stl); - Interface::matrix_from_stl(C,C_stl); - - _cost = 0; - for (int j=0; j<_size; ++j) - { - double r = std::max(_size - j -1,0); - _cost += 2*(r*j+r+j); - } - } - - // invalidate copy ctor - - Action_cholesky( const Action_cholesky & ) - { - INFOS("illegal call to Action_cholesky Copy Ctor"); - exit(1); - } - - // Dtor - - ~Action_cholesky( void ){ - - MESSAGE("Action_cholesky Dtor"); - - // deallocation - Interface::free_matrix(X_ref,_size); - Interface::free_matrix(X,_size); - Interface::free_matrix(C,_size); - } - - // action name - - static inline std::string name( void ) - { - return "cholesky_"+Interface::name(); - } - - double nb_op_base( void ){ - return _cost; - } - - inline void initialize( void ){ - Interface::copy_matrix(X_ref,X,_size); - } - - inline void calculate( void ) { - Interface::cholesky(X,C,_size); - } - - void check_result( void ){ - // calculation check -// STL_interface::cholesky(X_stl,C_stl,_size); -// -// typename Interface::real_type error= -// STL_interface::norm_diff(C_stl,resu_stl); -// -// if (error>1.e-6){ -// INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); -// } - - } - -private : - - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix C_stl; - - typename Interface::gene_matrix X_ref; - typename Interface::gene_matrix X; - typename Interface::gene_matrix C; - - int _size; - double _cost; -}; - -#endif diff --git a/eigen3/bench/btl/actions/action_ger.hh b/eigen3/bench/btl/actions/action_ger.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_ger.hh +++ /dev/null @@ -1,128 +0,0 @@ - -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_GER -#define ACTION_GER -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_ger { - -public : - - // Ctor - BTL_DONT_INLINE Action_ger( int size ):_size(size) - { - MESSAGE("Action_ger Ctor"); - - // STL matrix and vector initialization - typename Interface::stl_matrix tmp; - init_matrix(A_stl,_size); - init_vector(B_stl,_size); - init_vector(X_stl,_size); - init_vector(resu_stl,_size); - - // generic matrix and vector initialization - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(A,A_stl); - Interface::vector_from_stl(B_ref,B_stl); - Interface::vector_from_stl(B,B_stl); - Interface::vector_from_stl(X_ref,X_stl); - Interface::vector_from_stl(X,X_stl); - } - - // invalidate copy ctor - Action_ger( const Action_ger & ) - { - INFOS("illegal call to Action_ger Copy Ctor"); - exit(1); - } - - // Dtor - BTL_DONT_INLINE ~Action_ger( void ){ - MESSAGE("Action_ger Dtor"); - Interface::free_matrix(A,_size); - Interface::free_vector(B); - Interface::free_vector(X); - Interface::free_matrix(A_ref,_size); - Interface::free_vector(B_ref); - Interface::free_vector(X_ref); - - } - - // action name - static inline std::string name( void ) - { - return "ger_" + Interface::name(); - } - - double nb_op_base( void ){ - return 2.0*_size*_size; - } - - BTL_DONT_INLINE void initialize( void ){ - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_vector(B_ref,B,_size); - Interface::copy_vector(X_ref,X,_size); - } - - BTL_DONT_INLINE void calculate( void ) { - BTL_ASM_COMMENT("#begin ger"); - Interface::ger(A,B,X,_size); - BTL_ASM_COMMENT("end ger"); - } - - BTL_DONT_INLINE void check_result( void ){ - // calculation check - Interface::vector_to_stl(X,resu_stl); - - STL_interface::ger(A_stl,B_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-3){ - INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); - } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_vector B_stl; - typename Interface::stl_vector X_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_vector B_ref; - typename Interface::gene_vector X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_vector B; - typename Interface::gene_vector X; - - int _size; -}; - - -#endif diff --git a/eigen3/bench/btl/actions/action_hessenberg.hh b/eigen3/bench/btl/actions/action_hessenberg.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_hessenberg.hh +++ /dev/null @@ -1,233 +0,0 @@ -//===================================================== -// File : action_hessenberg.hh -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_HESSENBERG -#define ACTION_HESSENBERG -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_hessenberg { - -public : - - // Ctor - - Action_hessenberg( int size ):_size(size) - { - MESSAGE("Action_hessenberg Ctor"); - - // STL vector initialization - init_matrix(X_stl,_size); - - init_matrix(C_stl,_size); - init_matrix(resu_stl,_size); - - // generic matrix and vector initialization - Interface::matrix_from_stl(X_ref,X_stl); - Interface::matrix_from_stl(X,X_stl); - Interface::matrix_from_stl(C,C_stl); - - _cost = 0; - for (int j=0; j<_size-2; ++j) - { - double r = std::max(0,_size-j-1); - double b = std::max(0,_size-j-2); - _cost += 6 + 3*b + r*r*4 + r*_size*4; - } - } - - // invalidate copy ctor - - Action_hessenberg( const Action_hessenberg & ) - { - INFOS("illegal call to Action_hessenberg Copy Ctor"); - exit(1); - } - - // Dtor - - ~Action_hessenberg( void ){ - - MESSAGE("Action_hessenberg Dtor"); - - // deallocation - Interface::free_matrix(X_ref,_size); - Interface::free_matrix(X,_size); - Interface::free_matrix(C,_size); - } - - // action name - - static inline std::string name( void ) - { - return "hessenberg_"+Interface::name(); - } - - double nb_op_base( void ){ - return _cost; - } - - inline void initialize( void ){ - Interface::copy_matrix(X_ref,X,_size); - } - - inline void calculate( void ) { - Interface::hessenberg(X,C,_size); - } - - void check_result( void ){ - // calculation check - Interface::matrix_to_stl(C,resu_stl); - -// STL_interface::hessenberg(X_stl,C_stl,_size); -// -// typename Interface::real_type error= -// STL_interface::norm_diff(C_stl,resu_stl); -// -// if (error>1.e-6){ -// INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); -// } - - } - -private : - - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix C_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix X_ref; - typename Interface::gene_matrix X; - typename Interface::gene_matrix C; - - int _size; - double _cost; -}; - -template -class Action_tridiagonalization { - -public : - - // Ctor - - Action_tridiagonalization( int size ):_size(size) - { - MESSAGE("Action_tridiagonalization Ctor"); - - // STL vector initialization - init_matrix(X_stl,_size); - - for(int i=0; i<_size; ++i) - { - for(int j=0; j(C_stl,_size); - init_matrix(resu_stl,_size); - - // generic matrix and vector initialization - Interface::matrix_from_stl(X_ref,X_stl); - Interface::matrix_from_stl(X,X_stl); - Interface::matrix_from_stl(C,C_stl); - - _cost = 0; - for (int j=0; j<_size-2; ++j) - { - double r = std::max(0,_size-j-1); - double b = std::max(0,_size-j-2); - _cost += 6. + 3.*b + r*r*8.; - } - } - - // invalidate copy ctor - - Action_tridiagonalization( const Action_tridiagonalization & ) - { - INFOS("illegal call to Action_tridiagonalization Copy Ctor"); - exit(1); - } - - // Dtor - - ~Action_tridiagonalization( void ){ - - MESSAGE("Action_tridiagonalization Dtor"); - - // deallocation - Interface::free_matrix(X_ref,_size); - Interface::free_matrix(X,_size); - Interface::free_matrix(C,_size); - } - - // action name - - static inline std::string name( void ) { return "tridiagonalization_"+Interface::name(); } - - double nb_op_base( void ){ - return _cost; - } - - inline void initialize( void ){ - Interface::copy_matrix(X_ref,X,_size); - } - - inline void calculate( void ) { - Interface::tridiagonalization(X,C,_size); - } - - void check_result( void ){ - // calculation check - Interface::matrix_to_stl(C,resu_stl); - -// STL_interface::tridiagonalization(X_stl,C_stl,_size); -// -// typename Interface::real_type error= -// STL_interface::norm_diff(C_stl,resu_stl); -// -// if (error>1.e-6){ -// INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); -// } - - } - -private : - - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix C_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix X_ref; - typename Interface::gene_matrix X; - typename Interface::gene_matrix C; - - int _size; - double _cost; -}; - -#endif diff --git a/eigen3/bench/btl/actions/action_lu_decomp.hh b/eigen3/bench/btl/actions/action_lu_decomp.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_lu_decomp.hh +++ /dev/null @@ -1,124 +0,0 @@ -//===================================================== -// File : action_lu_decomp.hh -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_LU_DECOMP -#define ACTION_LU_DECOMP -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_lu_decomp { - -public : - - // Ctor - - Action_lu_decomp( int size ):_size(size) - { - MESSAGE("Action_lu_decomp Ctor"); - - // STL vector initialization - init_matrix(X_stl,_size); - - init_matrix(C_stl,_size); - init_matrix(resu_stl,_size); - - // generic matrix and vector initialization - Interface::matrix_from_stl(X_ref,X_stl); - Interface::matrix_from_stl(X,X_stl); - Interface::matrix_from_stl(C,C_stl); - - _cost = 2.0*size*size*size/3.0 + size*size; - } - - // invalidate copy ctor - - Action_lu_decomp( const Action_lu_decomp & ) - { - INFOS("illegal call to Action_lu_decomp Copy Ctor"); - exit(1); - } - - // Dtor - - ~Action_lu_decomp( void ){ - - MESSAGE("Action_lu_decomp Dtor"); - - // deallocation - Interface::free_matrix(X_ref,_size); - Interface::free_matrix(X,_size); - Interface::free_matrix(C,_size); - } - - // action name - - static inline std::string name( void ) - { - return "complete_lu_decomp_"+Interface::name(); - } - - double nb_op_base( void ){ - return _cost; - } - - inline void initialize( void ){ - Interface::copy_matrix(X_ref,X,_size); - } - - inline void calculate( void ) { - Interface::lu_decomp(X,C,_size); - } - - void check_result( void ){ - // calculation check - Interface::matrix_to_stl(C,resu_stl); - -// STL_interface::lu_decomp(X_stl,C_stl,_size); -// -// typename Interface::real_type error= -// STL_interface::norm_diff(C_stl,resu_stl); -// -// if (error>1.e-6){ -// INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); -// } - - } - -private : - - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix C_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix X_ref; - typename Interface::gene_matrix X; - typename Interface::gene_matrix C; - - int _size; - double _cost; -}; - -#endif diff --git a/eigen3/bench/btl/actions/action_lu_solve.hh b/eigen3/bench/btl/actions/action_lu_solve.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_lu_solve.hh +++ /dev/null @@ -1,136 +0,0 @@ -//===================================================== -// File : action_lu_solve.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_LU_SOLVE -#define ACTION_LU_SOLVE -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_lu_solve -{ - -public : - - static inline std::string name( void ) - { - return "lu_solve_"+Interface::name(); - } - - static double nb_op_base(int size){ - return 2.0*size*size*size/3.0; // questionable but not really important - } - - - static double calculate( int nb_calc, int size ) { - - // STL matrix and vector initialization - - typename Interface::stl_matrix A_stl; - typename Interface::stl_vector B_stl; - typename Interface::stl_vector X_stl; - - init_matrix(A_stl,size); - init_vector(B_stl,size); - init_vector(X_stl,size); - - // generic matrix and vector initialization - - typename Interface::gene_matrix A; - typename Interface::gene_vector B; - typename Interface::gene_vector X; - - typename Interface::gene_matrix LU; - - Interface::matrix_from_stl(A,A_stl); - Interface::vector_from_stl(B,B_stl); - Interface::vector_from_stl(X,X_stl); - Interface::matrix_from_stl(LU,A_stl); - - // local variable : - - typename Interface::Pivot_Vector pivot; // pivot vector - Interface::new_Pivot_Vector(pivot,size); - - // timer utilities - - Portable_Timer chronos; - - // time measurement - - chronos.start(); - - for (int ii=0;ii::matrix_vector_product(A_stl,X_stl,B_new_stl,size); - - typename Interface::real_type error= - STL_interface::norm_diff(B_stl,B_new_stl); - - if (error>1.e-5){ - INFOS("WRONG CALCULATION...residual=" << error); - STL_interface::display_vector(B_stl); - STL_interface::display_vector(B_new_stl); - exit(0); - } - - // deallocation and return time - - Interface::free_matrix(A,size); - Interface::free_vector(B); - Interface::free_vector(X); - Interface::free_Pivot_Vector(pivot); - - return time; - } - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_matrix_matrix_product.hh b/eigen3/bench/btl/actions/action_matrix_matrix_product.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_matrix_matrix_product.hh +++ /dev/null @@ -1,150 +0,0 @@ -//===================================================== -// File : action_matrix_matrix_product.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_MATRIX_MATRIX_PRODUCT -#define ACTION_MATRIX_MATRIX_PRODUCT -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_matrix_matrix_product { - -public : - - // Ctor - - Action_matrix_matrix_product( int size ):_size(size) - { - MESSAGE("Action_matrix_matrix_product Ctor"); - - // STL matrix and vector initialization - - init_matrix(A_stl,_size); - init_matrix(B_stl,_size); - init_matrix(X_stl,_size); - init_matrix(resu_stl,_size); - - // generic matrix and vector initialization - - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(B_ref,B_stl); - Interface::matrix_from_stl(X_ref,X_stl); - - Interface::matrix_from_stl(A,A_stl); - Interface::matrix_from_stl(B,B_stl); - Interface::matrix_from_stl(X,X_stl); - - } - - // invalidate copy ctor - - Action_matrix_matrix_product( const Action_matrix_matrix_product & ) - { - INFOS("illegal call to Action_matrix_matrix_product Copy Ctor"); - exit(0); - } - - // Dtor - - ~Action_matrix_matrix_product( void ){ - - MESSAGE("Action_matrix_matrix_product Dtor"); - - // deallocation - - Interface::free_matrix(A,_size); - Interface::free_matrix(B,_size); - Interface::free_matrix(X,_size); - - Interface::free_matrix(A_ref,_size); - Interface::free_matrix(B_ref,_size); - Interface::free_matrix(X_ref,_size); - - } - - // action name - - static inline std::string name( void ) - { - return "matrix_matrix_"+Interface::name(); - } - - double nb_op_base( void ){ - return 2.0*_size*_size*_size; - } - - inline void initialize( void ){ - - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_matrix(B_ref,B,_size); - Interface::copy_matrix(X_ref,X,_size); - - } - - inline void calculate( void ) { - Interface::matrix_matrix_product(A,B,X,_size); - } - - void check_result( void ){ - - // calculation check - if (_size<200) - { - Interface::matrix_to_stl(X,resu_stl); - STL_interface::matrix_matrix_product(A_stl,B_stl,X_stl,_size); - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - if (error>1.e-6){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(1); - } - } - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_matrix B_stl; - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_matrix B_ref; - typename Interface::gene_matrix X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_matrix B; - typename Interface::gene_matrix X; - - - int _size; - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_matrix_matrix_product_bis.hh b/eigen3/bench/btl/actions/action_matrix_matrix_product_bis.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_matrix_matrix_product_bis.hh +++ /dev/null @@ -1,152 +0,0 @@ -//===================================================== -// File : action_matrix_matrix_product_bis.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_MATRIX_MATRIX_PRODUCT_BIS -#define ACTION_MATRIX_MATRIX_PRODUCT_BIS -#include "utilities.h" -#include "STL_interface.hh" -#include "STL_timer.hh" -#include -#include "init_function.hh" -#include "init_vector.hh" -#include "init_matrix.hh" - -using namespace std; - -template -class Action_matrix_matrix_product_bis { - -public : - - static inline std::string name( void ) - { - return "matrix_matrix_"+Interface::name(); - } - - static double nb_op_base(int size){ - return 2.0*size*size*size; - } - - static double calculate( int nb_calc, int size ) { - - // STL matrix and vector initialization - - typename Interface::stl_matrix A_stl; - typename Interface::stl_matrix B_stl; - typename Interface::stl_matrix X_stl; - - init_matrix(A_stl,size); - init_matrix(B_stl,size); - init_matrix(X_stl,size); - - // generic matrix and vector initialization - - typename Interface::gene_matrix A_ref; - typename Interface::gene_matrix B_ref; - typename Interface::gene_matrix X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_matrix B; - typename Interface::gene_matrix X; - - - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(B_ref,B_stl); - Interface::matrix_from_stl(X_ref,X_stl); - - Interface::matrix_from_stl(A,A_stl); - Interface::matrix_from_stl(B,B_stl); - Interface::matrix_from_stl(X,X_stl); - - - // STL_timer utilities - - STL_timer chronos; - - // Baseline evaluation - - chronos.start_baseline(nb_calc); - - do { - - Interface::copy_matrix(A_ref,A,size); - Interface::copy_matrix(B_ref,B,size); - Interface::copy_matrix(X_ref,X,size); - - - // Interface::matrix_matrix_product(A,B,X,size); This line must be commented !!!! - } - while(chronos.check()); - - chronos.report(true); - - // Time measurement - - chronos.start(nb_calc); - - do { - - Interface::copy_matrix(A_ref,A,size); - Interface::copy_matrix(B_ref,B,size); - Interface::copy_matrix(X_ref,X,size); - - Interface::matrix_matrix_product(A,B,X,size); // here it is not commented !!!! - } - while(chronos.check()); - - chronos.report(true); - - double time=chronos.calculated_time/2000.0; - - // calculation check - - typename Interface::stl_matrix resu_stl(size); - - Interface::matrix_to_stl(X,resu_stl); - - STL_interface::matrix_matrix_product(A_stl,B_stl,X_stl,size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-6){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(1); - } - - // deallocation and return time - - Interface::free_matrix(A,size); - Interface::free_matrix(B,size); - Interface::free_matrix(X,size); - - Interface::free_matrix(A_ref,size); - Interface::free_matrix(B_ref,size); - Interface::free_matrix(X_ref,size); - - return time; - } - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_matrix_vector_product.hh b/eigen3/bench/btl/actions/action_matrix_vector_product.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_matrix_vector_product.hh +++ /dev/null @@ -1,153 +0,0 @@ -//===================================================== -// File : action_matrix_vector_product.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_MATRIX_VECTOR_PRODUCT -#define ACTION_MATRIX_VECTOR_PRODUCT -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_matrix_vector_product { - -public : - - // Ctor - - BTL_DONT_INLINE Action_matrix_vector_product( int size ):_size(size) - { - MESSAGE("Action_matrix_vector_product Ctor"); - - // STL matrix and vector initialization - - init_matrix(A_stl,_size); - init_vector(B_stl,_size); - init_vector(X_stl,_size); - init_vector(resu_stl,_size); - - // generic matrix and vector initialization - - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(A,A_stl); - Interface::vector_from_stl(B_ref,B_stl); - Interface::vector_from_stl(B,B_stl); - Interface::vector_from_stl(X_ref,X_stl); - Interface::vector_from_stl(X,X_stl); - - } - - // invalidate copy ctor - - Action_matrix_vector_product( const Action_matrix_vector_product & ) - { - INFOS("illegal call to Action_matrix_vector_product Copy Ctor"); - exit(1); - } - - // Dtor - - BTL_DONT_INLINE ~Action_matrix_vector_product( void ){ - - MESSAGE("Action_matrix_vector_product Dtor"); - - // deallocation - - Interface::free_matrix(A,_size); - Interface::free_vector(B); - Interface::free_vector(X); - - Interface::free_matrix(A_ref,_size); - Interface::free_vector(B_ref); - Interface::free_vector(X_ref); - - } - - // action name - - static inline std::string name( void ) - { - return "matrix_vector_" + Interface::name(); - } - - double nb_op_base( void ){ - return 2.0*_size*_size; - } - - BTL_DONT_INLINE void initialize( void ){ - - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_vector(B_ref,B,_size); - Interface::copy_vector(X_ref,X,_size); - - } - - BTL_DONT_INLINE void calculate( void ) { - BTL_ASM_COMMENT("#begin matrix_vector_product"); - Interface::matrix_vector_product(A,B,X,_size); - BTL_ASM_COMMENT("end matrix_vector_product"); - } - - BTL_DONT_INLINE void check_result( void ){ - - // calculation check - - Interface::vector_to_stl(X,resu_stl); - - STL_interface::matrix_vector_product(A_stl,B_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-5){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(0); - } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_vector B_stl; - typename Interface::stl_vector X_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_vector B_ref; - typename Interface::gene_vector X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_vector B; - typename Interface::gene_vector X; - - - int _size; - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_partial_lu.hh b/eigen3/bench/btl/actions/action_partial_lu.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_partial_lu.hh +++ /dev/null @@ -1,125 +0,0 @@ -//===================================================== -// File : action_lu_decomp.hh -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_PARTIAL_LU -#define ACTION_PARTIAL_LU -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_partial_lu { - -public : - - // Ctor - - Action_partial_lu( int size ):_size(size) - { - MESSAGE("Action_partial_lu Ctor"); - - // STL vector initialization - init_matrix(X_stl,_size); - init_matrix(C_stl,_size); - - // make sure X is invertible - for (int i=0; i<_size; ++i) - X_stl[i][i] = X_stl[i][i] * 1e2 + 1; - - // generic matrix and vector initialization - Interface::matrix_from_stl(X_ref,X_stl); - Interface::matrix_from_stl(X,X_stl); - Interface::matrix_from_stl(C,C_stl); - - _cost = 2.0*size*size*size/3.0 + size*size; - } - - // invalidate copy ctor - - Action_partial_lu( const Action_partial_lu & ) - { - INFOS("illegal call to Action_partial_lu Copy Ctor"); - exit(1); - } - - // Dtor - - ~Action_partial_lu( void ){ - - MESSAGE("Action_partial_lu Dtor"); - - // deallocation - Interface::free_matrix(X_ref,_size); - Interface::free_matrix(X,_size); - Interface::free_matrix(C,_size); - } - - // action name - - static inline std::string name( void ) - { - return "partial_lu_decomp_"+Interface::name(); - } - - double nb_op_base( void ){ - return _cost; - } - - inline void initialize( void ){ - Interface::copy_matrix(X_ref,X,_size); - } - - inline void calculate( void ) { - Interface::partial_lu_decomp(X,C,_size); - } - - void check_result( void ){ - // calculation check -// Interface::matrix_to_stl(C,resu_stl); - -// STL_interface::lu_decomp(X_stl,C_stl,_size); -// -// typename Interface::real_type error= -// STL_interface::norm_diff(C_stl,resu_stl); -// -// if (error>1.e-6){ -// INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); -// } - - } - -private : - - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix C_stl; - - typename Interface::gene_matrix X_ref; - typename Interface::gene_matrix X; - typename Interface::gene_matrix C; - - int _size; - double _cost; -}; - -#endif diff --git a/eigen3/bench/btl/actions/action_rot.hh b/eigen3/bench/btl/actions/action_rot.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_rot.hh +++ /dev/null @@ -1,116 +0,0 @@ - -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_ROT -#define ACTION_ROT -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_rot { - -public : - - // Ctor - BTL_DONT_INLINE Action_rot( int size ):_size(size) - { - MESSAGE("Action_rot Ctor"); - - // STL matrix and vector initialization - typename Interface::stl_matrix tmp; - init_vector(A_stl,_size); - init_vector(B_stl,_size); - - // generic matrix and vector initialization - Interface::vector_from_stl(A_ref,A_stl); - Interface::vector_from_stl(A,A_stl); - Interface::vector_from_stl(B_ref,B_stl); - Interface::vector_from_stl(B,B_stl); - } - - // invalidate copy ctor - Action_rot( const Action_rot & ) - { - INFOS("illegal call to Action_rot Copy Ctor"); - exit(1); - } - - // Dtor - BTL_DONT_INLINE ~Action_rot( void ){ - MESSAGE("Action_rot Dtor"); - Interface::free_vector(A); - Interface::free_vector(B); - Interface::free_vector(A_ref); - Interface::free_vector(B_ref); - } - - // action name - static inline std::string name( void ) - { - return "rot_" + Interface::name(); - } - - double nb_op_base( void ){ - return 6.0*_size; - } - - BTL_DONT_INLINE void initialize( void ){ - Interface::copy_vector(A_ref,A,_size); - Interface::copy_vector(B_ref,B,_size); - } - - BTL_DONT_INLINE void calculate( void ) { - BTL_ASM_COMMENT("#begin rot"); - Interface::rot(A,B,0.5,0.6,_size); - BTL_ASM_COMMENT("end rot"); - } - - BTL_DONT_INLINE void check_result( void ){ - // calculation check -// Interface::vector_to_stl(X,resu_stl); - -// STL_interface::rot(A_stl,B_stl,X_stl,_size); - -// typename Interface::real_type error= -// STL_interface::norm_diff(X_stl,resu_stl); - -// if (error>1.e-3){ -// INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); -// } - - } - -private : - - typename Interface::stl_vector A_stl; - typename Interface::stl_vector B_stl; - - typename Interface::gene_vector A_ref; - typename Interface::gene_vector B_ref; - - typename Interface::gene_vector A; - typename Interface::gene_vector B; - - int _size; -}; - - -#endif diff --git a/eigen3/bench/btl/actions/action_symv.hh b/eigen3/bench/btl/actions/action_symv.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_symv.hh +++ /dev/null @@ -1,139 +0,0 @@ -//===================================================== -// File : action_symv.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_SYMV -#define ACTION_SYMV -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_symv { - -public : - - // Ctor - - BTL_DONT_INLINE Action_symv( int size ):_size(size) - { - MESSAGE("Action_symv Ctor"); - - // STL matrix and vector initialization - init_matrix_symm(A_stl,_size); - init_vector(B_stl,_size); - init_vector(X_stl,_size); - init_vector(resu_stl,_size); - - // generic matrix and vector initialization - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(A,A_stl); - Interface::vector_from_stl(B_ref,B_stl); - Interface::vector_from_stl(B,B_stl); - Interface::vector_from_stl(X_ref,X_stl); - Interface::vector_from_stl(X,X_stl); - - } - - // invalidate copy ctor - - Action_symv( const Action_symv & ) - { - INFOS("illegal call to Action_symv Copy Ctor"); - exit(1); - } - - // Dtor - BTL_DONT_INLINE ~Action_symv( void ){ - Interface::free_matrix(A,_size); - Interface::free_vector(B); - Interface::free_vector(X); - Interface::free_matrix(A_ref,_size); - Interface::free_vector(B_ref); - Interface::free_vector(X_ref); - } - - // action name - - static inline std::string name( void ) - { - return "symv_" + Interface::name(); - } - - double nb_op_base( void ){ - return 2.0*_size*_size; - } - - BTL_DONT_INLINE void initialize( void ){ - - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_vector(B_ref,B,_size); - Interface::copy_vector(X_ref,X,_size); - - } - - BTL_DONT_INLINE void calculate( void ) { - BTL_ASM_COMMENT("#begin symv"); - Interface::symv(A,B,X,_size); - BTL_ASM_COMMENT("end symv"); - } - - BTL_DONT_INLINE void check_result( void ){ - if (_size>128) return; - // calculation check - Interface::vector_to_stl(X,resu_stl); - - STL_interface::symv(A_stl,B_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-5){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(0); - } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_vector B_stl; - typename Interface::stl_vector X_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_vector B_ref; - typename Interface::gene_vector X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_vector B; - typename Interface::gene_vector X; - - - int _size; - -}; - - -#endif diff --git a/eigen3/bench/btl/actions/action_syr2.hh b/eigen3/bench/btl/actions/action_syr2.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_syr2.hh +++ /dev/null @@ -1,133 +0,0 @@ -//===================================================== -// File : action_syr2.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_SYR2 -#define ACTION_SYR2 -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_syr2 { - -public : - - // Ctor - - BTL_DONT_INLINE Action_syr2( int size ):_size(size) - { - // STL matrix and vector initialization - typename Interface::stl_matrix tmp; - init_matrix(A_stl,_size); - init_vector(B_stl,_size); - init_vector(X_stl,_size); - init_vector(resu_stl,_size); - - // generic matrix and vector initialization - Interface::matrix_from_stl(A_ref,A_stl); - Interface::matrix_from_stl(A,A_stl); - Interface::vector_from_stl(B_ref,B_stl); - Interface::vector_from_stl(B,B_stl); - Interface::vector_from_stl(X_ref,X_stl); - Interface::vector_from_stl(X,X_stl); - } - - // invalidate copy ctor - Action_syr2( const Action_syr2 & ) - { - INFOS("illegal call to Action_syr2 Copy Ctor"); - exit(1); - } - - // Dtor - BTL_DONT_INLINE ~Action_syr2( void ){ - Interface::free_matrix(A,_size); - Interface::free_vector(B); - Interface::free_vector(X); - Interface::free_matrix(A_ref,_size); - Interface::free_vector(B_ref); - Interface::free_vector(X_ref); - } - - // action name - - static inline std::string name( void ) - { - return "syr2_" + Interface::name(); - } - - double nb_op_base( void ){ - return 2.0*_size*_size; - } - - BTL_DONT_INLINE void initialize( void ){ - Interface::copy_matrix(A_ref,A,_size); - Interface::copy_vector(B_ref,B,_size); - Interface::copy_vector(X_ref,X,_size); - } - - BTL_DONT_INLINE void calculate( void ) { - BTL_ASM_COMMENT("#begin syr2"); - Interface::syr2(A,B,X,_size); - BTL_ASM_COMMENT("end syr2"); - } - - BTL_DONT_INLINE void check_result( void ){ - // calculation check - Interface::vector_to_stl(X,resu_stl); - - STL_interface::syr2(A_stl,B_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-3){ - INFOS("WRONG CALCULATION...residual=" << error); -// exit(0); - } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_vector B_stl; - typename Interface::stl_vector X_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_vector B_ref; - typename Interface::gene_vector X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_vector B; - typename Interface::gene_vector X; - - - int _size; - -}; - - -#endif diff --git a/eigen3/bench/btl/actions/action_trisolve.hh b/eigen3/bench/btl/actions/action_trisolve.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_trisolve.hh +++ /dev/null @@ -1,137 +0,0 @@ -//===================================================== -// File : action_trisolve.hh -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_TRISOLVE -#define ACTION_TRISOLVE -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_trisolve { - -public : - - // Ctor - - Action_trisolve( int size ):_size(size) - { - MESSAGE("Action_trisolve Ctor"); - - // STL vector initialization - init_matrix(L_stl,_size); - init_vector(B_stl,_size); - init_vector(X_stl,_size); - for (int j=0; j<_size; ++j) - { - for (int i=0; i(resu_stl,_size); - - // generic matrix and vector initialization - Interface::matrix_from_stl(L,L_stl); - Interface::vector_from_stl(X,X_stl); - Interface::vector_from_stl(B,B_stl); - - _cost = 0; - for (int j=0; j<_size; ++j) - { - _cost += 2*j + 1; - } - } - - // invalidate copy ctor - - Action_trisolve( const Action_trisolve & ) - { - INFOS("illegal call to Action_trisolve Copy Ctor"); - exit(1); - } - - // Dtor - - ~Action_trisolve( void ){ - - MESSAGE("Action_trisolve Dtor"); - - // deallocation - Interface::free_matrix(L,_size); - Interface::free_vector(B); - Interface::free_vector(X); - } - - // action name - - static inline std::string name( void ) - { - return "trisolve_vector_"+Interface::name(); - } - - double nb_op_base( void ){ - return _cost; - } - - inline void initialize( void ){ - //Interface::copy_vector(X_ref,X,_size); - } - - inline void calculate( void ) { - Interface::trisolve_lower(L,B,X,_size); - } - - void check_result(){ - if (_size>128) return; - // calculation check - Interface::vector_to_stl(X,resu_stl); - - STL_interface::trisolve_lower(L_stl,B_stl,X_stl,_size); - - typename Interface::real_type error= - STL_interface::norm_diff(X_stl,resu_stl); - - if (error>1.e-4){ - INFOS("WRONG CALCULATION...residual=" << error); - exit(2); - } //else INFOS("CALCULATION OK...residual=" << error); - - } - -private : - - typename Interface::stl_matrix L_stl; - typename Interface::stl_vector X_stl; - typename Interface::stl_vector B_stl; - typename Interface::stl_vector resu_stl; - - typename Interface::gene_matrix L; - typename Interface::gene_vector X; - typename Interface::gene_vector B; - - int _size; - double _cost; -}; - -#endif diff --git a/eigen3/bench/btl/actions/action_trisolve_matrix.hh b/eigen3/bench/btl/actions/action_trisolve_matrix.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_trisolve_matrix.hh +++ /dev/null @@ -1,165 +0,0 @@ -//===================================================== -// File : action_matrix_matrix_product.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_TRISOLVE_MATRIX_PRODUCT -#define ACTION_TRISOLVE_MATRIX_PRODUCT -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_trisolve_matrix { - -public : - - // Ctor - - Action_trisolve_matrix( int size ):_size(size) - { - MESSAGE("Action_trisolve_matrix Ctor"); - - // STL matrix and vector initialization - - init_matrix(A_stl,_size); - init_matrix(B_stl,_size); - init_matrix(X_stl,_size); - init_matrix(resu_stl,_size); - - for (int j=0; j<_size; ++j) - { - for (int i=0; i::matrix_matrix_product(A_stl,B_stl,X_stl,_size); -// -// typename Interface::real_type error= -// STL_interface::norm_diff(X_stl,resu_stl); -// -// if (error>1.e-6){ -// INFOS("WRONG CALCULATION...residual=" << error); -// // exit(1); -// } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_matrix B_stl; - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_matrix B_ref; - typename Interface::gene_matrix X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_matrix B; - typename Interface::gene_matrix X; - - int _size; - double _cost; - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/action_trmm.hh b/eigen3/bench/btl/actions/action_trmm.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/action_trmm.hh +++ /dev/null @@ -1,165 +0,0 @@ -//===================================================== -// File : action_matrix_matrix_product.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef ACTION_TRMM -#define ACTION_TRMM -#include "utilities.h" -#include "STL_interface.hh" -#include -#include "init/init_function.hh" -#include "init/init_vector.hh" -#include "init/init_matrix.hh" - -using namespace std; - -template -class Action_trmm { - -public : - - // Ctor - - Action_trmm( int size ):_size(size) - { - MESSAGE("Action_trmm Ctor"); - - // STL matrix and vector initialization - - init_matrix(A_stl,_size); - init_matrix(B_stl,_size); - init_matrix(X_stl,_size); - init_matrix(resu_stl,_size); - - for (int j=0; j<_size; ++j) - { - for (int i=0; i::matrix_matrix_product(A_stl,B_stl,X_stl,_size); -// -// typename Interface::real_type error= -// STL_interface::norm_diff(X_stl,resu_stl); -// -// if (error>1.e-6){ -// INFOS("WRONG CALCULATION...residual=" << error); -// // exit(1); -// } - - } - -private : - - typename Interface::stl_matrix A_stl; - typename Interface::stl_matrix B_stl; - typename Interface::stl_matrix X_stl; - typename Interface::stl_matrix resu_stl; - - typename Interface::gene_matrix A_ref; - typename Interface::gene_matrix B_ref; - typename Interface::gene_matrix X_ref; - - typename Interface::gene_matrix A; - typename Interface::gene_matrix B; - typename Interface::gene_matrix X; - - int _size; - double _cost; - -}; - - -#endif - - - diff --git a/eigen3/bench/btl/actions/basic_actions.hh b/eigen3/bench/btl/actions/basic_actions.hh deleted file mode 100644 --- a/eigen3/bench/btl/actions/basic_actions.hh +++ /dev/null @@ -1,21 +0,0 @@ - -#include "action_axpy.hh" -#include "action_axpby.hh" - -#include "action_matrix_vector_product.hh" -#include "action_atv_product.hh" - -#include "action_matrix_matrix_product.hh" -// #include "action_ata_product.hh" -#include "action_aat_product.hh" - -#include "action_trisolve.hh" -#include "action_trmm.hh" -#include "action_symv.hh" -// #include "action_symm.hh" -#include "action_syr2.hh" -#include "action_ger.hh" -#include "action_rot.hh" - -// #include "action_lu_solve.hh" - diff --git a/eigen3/bench/btl/cmake/FindACML.cmake b/eigen3/bench/btl/cmake/FindACML.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindACML.cmake +++ /dev/null @@ -1,49 +0,0 @@ - -if (ACML_LIBRARIES) - set(ACML_FIND_QUIETLY TRUE) -endif (ACML_LIBRARIES) - -find_library(ACML_LIBRARIES - NAMES - acml_mp acml_mv - PATHS - $ENV{ACMLDIR}/lib - $ENV{ACML_DIR}/lib - ${LIB_INSTALL_DIR} -) - -find_file(ACML_LIBRARIES - NAMES - libacml_mp.so - PATHS - /usr/lib - $ENV{ACMLDIR}/lib - ${LIB_INSTALL_DIR} -) - -if(NOT ACML_LIBRARIES) - message(STATUS "Multi-threaded library not found, looking for single-threaded") - find_library(ACML_LIBRARIES - NAMES - acml acml_mv - PATHS - $ENV{ACMLDIR}/lib - $ENV{ACML_DIR}/lib - ${LIB_INSTALL_DIR} - ) - find_file(ACML_LIBRARIES - libacml.so libacml_mv.so - PATHS - /usr/lib - $ENV{ACMLDIR}/lib - ${LIB_INSTALL_DIR} - ) -endif() - - - - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(ACML DEFAULT_MSG ACML_LIBRARIES) - -mark_as_advanced(ACML_LIBRARIES) diff --git a/eigen3/bench/btl/cmake/FindATLAS.cmake b/eigen3/bench/btl/cmake/FindATLAS.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindATLAS.cmake +++ /dev/null @@ -1,39 +0,0 @@ - -if (ATLAS_LIBRARIES) - set(ATLAS_FIND_QUIETLY TRUE) -endif (ATLAS_LIBRARIES) - -find_file(ATLAS_LIB libatlas.so.3 PATHS /usr/lib $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) -find_library(ATLAS_LIB atlas PATHS $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) - -find_file(ATLAS_CBLAS libcblas.so.3 PATHS /usr/lib $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) -find_library(ATLAS_CBLAS cblas PATHS $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) - -find_file(ATLAS_LAPACK liblapack_atlas.so.3 PATHS /usr/lib $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) -find_library(ATLAS_LAPACK lapack_atlas PATHS $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) - -if(NOT ATLAS_LAPACK) - find_file(ATLAS_LAPACK liblapack.so.3 PATHS /usr/lib/atlas $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) - find_library(ATLAS_LAPACK lapack PATHS $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) -endif(NOT ATLAS_LAPACK) - -find_file(ATLAS_F77BLAS libf77blas.so.3 PATHS /usr/lib $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) -find_library(ATLAS_F77BLAS f77blas PATHS $ENV{ATLASDIR} ${LIB_INSTALL_DIR}) - -if(ATLAS_LIB AND ATLAS_CBLAS AND ATLAS_LAPACK AND ATLAS_F77BLAS) - - set(ATLAS_LIBRARIES ${ATLAS_LAPACK} ${ATLAS_CBLAS} ${ATLAS_F77BLAS} ${ATLAS_LIB}) - - # search the default lapack lib link to it - find_file(ATLAS_REFERENCE_LAPACK liblapack.so.3 PATHS /usr/lib /usr/lib64) - find_library(ATLAS_REFERENCE_LAPACK NAMES lapack) - if(ATLAS_REFERENCE_LAPACK) - set(ATLAS_LIBRARIES ${ATLAS_LIBRARIES} ${ATLAS_REFERENCE_LAPACK}) - endif() - -endif(ATLAS_LIB AND ATLAS_CBLAS AND ATLAS_LAPACK AND ATLAS_F77BLAS) - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(ATLAS DEFAULT_MSG ATLAS_LIBRARIES) - -mark_as_advanced(ATLAS_LIBRARIES) diff --git a/eigen3/bench/btl/cmake/FindBlitz.cmake b/eigen3/bench/btl/cmake/FindBlitz.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindBlitz.cmake +++ /dev/null @@ -1,40 +0,0 @@ -# - Try to find blitz lib -# Once done this will define -# -# BLITZ_FOUND - system has blitz lib -# BLITZ_INCLUDES - the blitz include directory -# BLITZ_LIBRARIES - The libraries needed to use blitz - -# Copyright (c) 2006, Montel Laurent, -# Copyright (c) 2007, Allen Winter, -# Copyright (C) 2008 Gael Guennebaud -# Redistribution and use is allowed according to the terms of the BSD license. -# For details see the accompanying COPYING-CMAKE-SCRIPTS file. - -# include(FindLibraryWithDebug) - -if (BLITZ_INCLUDES AND BLITZ_LIBRARIES) - set(Blitz_FIND_QUIETLY TRUE) -endif (BLITZ_INCLUDES AND BLITZ_LIBRARIES) - -find_path(BLITZ_INCLUDES - NAMES - blitz/array.h - PATH_SUFFIXES blitz* - PATHS - $ENV{BLITZDIR}/include - ${INCLUDE_INSTALL_DIR} -) - -find_library(BLITZ_LIBRARIES - blitz - PATHS - $ENV{BLITZDIR}/lib - ${LIB_INSTALL_DIR} -) - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(Blitz DEFAULT_MSG - BLITZ_INCLUDES BLITZ_LIBRARIES) - -mark_as_advanced(BLITZ_INCLUDES BLITZ_LIBRARIES) diff --git a/eigen3/bench/btl/cmake/FindCBLAS.cmake b/eigen3/bench/btl/cmake/FindCBLAS.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindCBLAS.cmake +++ /dev/null @@ -1,34 +0,0 @@ -# include(FindLibraryWithDebug) - -if (CBLAS_INCLUDES AND CBLAS_LIBRARIES) - set(CBLAS_FIND_QUIETLY TRUE) -endif (CBLAS_INCLUDES AND CBLAS_LIBRARIES) - -find_path(CBLAS_INCLUDES - NAMES - cblas.h - PATHS - $ENV{CBLASDIR}/include - ${INCLUDE_INSTALL_DIR} -) - -find_library(CBLAS_LIBRARIES - cblas - PATHS - $ENV{CBLASDIR}/lib - ${LIB_INSTALL_DIR} -) - -find_file(CBLAS_LIBRARIES - libcblas.so.3 - PATHS - /usr/lib - $ENV{CBLASDIR}/lib - ${LIB_INSTALL_DIR} -) - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(CBLAS DEFAULT_MSG - CBLAS_INCLUDES CBLAS_LIBRARIES) - -mark_as_advanced(CBLAS_INCLUDES CBLAS_LIBRARIES) diff --git a/eigen3/bench/btl/cmake/FindGMM.cmake b/eigen3/bench/btl/cmake/FindGMM.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindGMM.cmake +++ /dev/null @@ -1,17 +0,0 @@ -if (GMM_INCLUDE_DIR) - # in cache already - set(GMM_FOUND TRUE) -else (GMM_INCLUDE_DIR) - -find_path(GMM_INCLUDE_DIR NAMES gmm/gmm.h - PATHS - ${INCLUDE_INSTALL_DIR} - ${GMM_INCLUDE_PATH} - ) - -include(FindPackageHandleStandardArgs) -FIND_PACKAGE_HANDLE_STANDARD_ARGS(GMM DEFAULT_MSG GMM_INCLUDE_DIR ) - -mark_as_advanced(GMM_INCLUDE_DIR) - -endif(GMM_INCLUDE_DIR) diff --git a/eigen3/bench/btl/cmake/FindGOTO.cmake b/eigen3/bench/btl/cmake/FindGOTO.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindGOTO.cmake +++ /dev/null @@ -1,15 +0,0 @@ - -if (GOTO_LIBRARIES) - set(GOTO_FIND_QUIETLY TRUE) -endif (GOTO_LIBRARIES) - -find_library(GOTO_LIBRARIES goto PATHS $ENV{GOTODIR} ${LIB_INSTALL_DIR}) - -if(GOTO_LIBRARIES AND CMAKE_COMPILER_IS_GNUCXX) - set(GOTO_LIBRARIES ${GOTO_LIBRARIES} "-lpthread -lgfortran") -endif() - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(GOTO DEFAULT_MSG GOTO_LIBRARIES) - -mark_as_advanced(GOTO_LIBRARIES) diff --git a/eigen3/bench/btl/cmake/FindGOTO2.cmake b/eigen3/bench/btl/cmake/FindGOTO2.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindGOTO2.cmake +++ /dev/null @@ -1,25 +0,0 @@ - -if (GOTO2_LIBRARIES) - set(GOTO2_FIND_QUIETLY TRUE) -endif (GOTO2_LIBRARIES) -# -# find_path(GOTO_INCLUDES -# NAMES -# cblas.h -# PATHS -# $ENV{GOTODIR}/include -# ${INCLUDE_INSTALL_DIR} -# ) - -find_file(GOTO2_LIBRARIES libgoto2.so PATHS /usr/lib $ENV{GOTO2DIR} ${LIB_INSTALL_DIR}) -find_library(GOTO2_LIBRARIES goto2 PATHS $ENV{GOTO2DIR} ${LIB_INSTALL_DIR}) - -if(GOTO2_LIBRARIES AND CMAKE_COMPILER_IS_GNUCXX) - set(GOTO2_LIBRARIES ${GOTO2_LIBRARIES} "-lpthread -lgfortran") -endif() - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(GOTO2 DEFAULT_MSG - GOTO2_LIBRARIES) - -mark_as_advanced(GOTO2_LIBRARIES) diff --git a/eigen3/bench/btl/cmake/FindMKL.cmake b/eigen3/bench/btl/cmake/FindMKL.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindMKL.cmake +++ /dev/null @@ -1,65 +0,0 @@ - -if (MKL_LIBRARIES) - set(MKL_FIND_QUIETLY TRUE) -endif (MKL_LIBRARIES) - -if(CMAKE_MINOR_VERSION GREATER 4) - -if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64") - -find_library(MKL_LIBRARIES - mkl_core - PATHS - $ENV{MKLLIB} - /opt/intel/mkl/*/lib/em64t - /opt/intel/Compiler/*/*/mkl/lib/em64t - ${LIB_INSTALL_DIR} -) - -find_library(MKL_GUIDE - guide - PATHS - $ENV{MKLLIB} - /opt/intel/mkl/*/lib/em64t - /opt/intel/Compiler/*/*/mkl/lib/em64t - /opt/intel/Compiler/*/*/lib/intel64 - ${LIB_INSTALL_DIR} -) - -if(MKL_LIBRARIES AND MKL_GUIDE) - set(MKL_LIBRARIES ${MKL_LIBRARIES} mkl_intel_lp64 mkl_sequential ${MKL_GUIDE} pthread) -endif() - -else(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64") - -find_library(MKL_LIBRARIES - mkl_core - PATHS - $ENV{MKLLIB} - /opt/intel/mkl/*/lib/32 - /opt/intel/Compiler/*/*/mkl/lib/32 - ${LIB_INSTALL_DIR} -) - -find_library(MKL_GUIDE - guide - PATHS - $ENV{MKLLIB} - /opt/intel/mkl/*/lib/32 - /opt/intel/Compiler/*/*/mkl/lib/32 - /opt/intel/Compiler/*/*/lib/intel32 - ${LIB_INSTALL_DIR} -) - -if(MKL_LIBRARIES AND MKL_GUIDE) - set(MKL_LIBRARIES ${MKL_LIBRARIES} mkl_intel mkl_sequential ${MKL_GUIDE} pthread) -endif() - -endif(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64") - -endif(CMAKE_MINOR_VERSION GREATER 4) - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(MKL DEFAULT_MSG MKL_LIBRARIES) - -mark_as_advanced(MKL_LIBRARIES) diff --git a/eigen3/bench/btl/cmake/FindMTL4.cmake b/eigen3/bench/btl/cmake/FindMTL4.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindMTL4.cmake +++ /dev/null @@ -1,31 +0,0 @@ -# - Try to find eigen2 headers -# Once done this will define -# -# MTL4_FOUND - system has eigen2 lib -# MTL4_INCLUDE_DIR - the eigen2 include directory -# -# Copyright (C) 2008 Gael Guennebaud -# Adapted from FindEigen.cmake: -# Copyright (c) 2006, 2007 Montel Laurent, -# Redistribution and use is allowed according to the terms of the BSD license. -# For details see the accompanying COPYING-CMAKE-SCRIPTS file. - -if (MTL4_INCLUDE_DIR) - - # in cache already - set(MTL4_FOUND TRUE) - -else (MTL4_INCLUDE_DIR) - -find_path(MTL4_INCLUDE_DIR NAMES boost/numeric/mtl/mtl.hpp - PATHS - ${INCLUDE_INSTALL_DIR} - ) - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(MTL4 DEFAULT_MSG MTL4_INCLUDE_DIR) - -mark_as_advanced(MTL4_INCLUDE_DIR) - -endif(MTL4_INCLUDE_DIR) - diff --git a/eigen3/bench/btl/cmake/FindPackageHandleStandardArgs.cmake b/eigen3/bench/btl/cmake/FindPackageHandleStandardArgs.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindPackageHandleStandardArgs.cmake +++ /dev/null @@ -1,60 +0,0 @@ -# FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME (DEFAULT_MSG|"Custom failure message") VAR1 ... ) -# -# This macro is intended to be used in FindXXX.cmake modules files. -# It handles the REQUIRED and QUIET argument to FIND_PACKAGE() and -# it also sets the _FOUND variable. -# The package is found if all variables listed are TRUE. -# Example: -# -# FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2 DEFAULT_MSG LIBXML2_LIBRARIES LIBXML2_INCLUDE_DIR) -# -# LibXml2 is considered to be found, if both LIBXML2_LIBRARIES and -# LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to TRUE. -# If it is not found and REQUIRED was used, it fails with FATAL_ERROR, -# independent whether QUIET was used or not. -# -# If it is found, the location is reported using the VAR1 argument, so -# here a message "Found LibXml2: /usr/lib/libxml2.so" will be printed out. -# If the second argument is DEFAULT_MSG, the message in the failure case will -# be "Could NOT find LibXml2", if you don't like this message you can specify -# your own custom failure message there. - -MACRO(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 ) - - IF("${_FAIL_MSG}" STREQUAL "DEFAULT_MSG") - IF (${_NAME}_FIND_REQUIRED) - SET(_FAIL_MESSAGE "Could not find REQUIRED package ${_NAME}") - ELSE (${_NAME}_FIND_REQUIRED) - SET(_FAIL_MESSAGE "Could not find OPTIONAL package ${_NAME}") - ENDIF (${_NAME}_FIND_REQUIRED) - ELSE("${_FAIL_MSG}" STREQUAL "DEFAULT_MSG") - SET(_FAIL_MESSAGE "${_FAIL_MSG}") - ENDIF("${_FAIL_MSG}" STREQUAL "DEFAULT_MSG") - - STRING(TOUPPER ${_NAME} _NAME_UPPER) - - SET(${_NAME_UPPER}_FOUND TRUE) - IF(NOT ${_VAR1}) - SET(${_NAME_UPPER}_FOUND FALSE) - ENDIF(NOT ${_VAR1}) - - FOREACH(_CURRENT_VAR ${ARGN}) - IF(NOT ${_CURRENT_VAR}) - SET(${_NAME_UPPER}_FOUND FALSE) - ENDIF(NOT ${_CURRENT_VAR}) - ENDFOREACH(_CURRENT_VAR) - - IF (${_NAME_UPPER}_FOUND) - IF (NOT ${_NAME}_FIND_QUIETLY) - MESSAGE(STATUS "Found ${_NAME}: ${${_VAR1}}") - ENDIF (NOT ${_NAME}_FIND_QUIETLY) - ELSE (${_NAME_UPPER}_FOUND) - IF (${_NAME}_FIND_REQUIRED) - MESSAGE(FATAL_ERROR "${_FAIL_MESSAGE}") - ELSE (${_NAME}_FIND_REQUIRED) - IF (NOT ${_NAME}_FIND_QUIETLY) - MESSAGE(STATUS "${_FAIL_MESSAGE}") - ENDIF (NOT ${_NAME}_FIND_QUIETLY) - ENDIF (${_NAME}_FIND_REQUIRED) - ENDIF (${_NAME_UPPER}_FOUND) -ENDMACRO(FIND_PACKAGE_HANDLE_STANDARD_ARGS) diff --git a/eigen3/bench/btl/cmake/FindTvmet.cmake b/eigen3/bench/btl/cmake/FindTvmet.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/FindTvmet.cmake +++ /dev/null @@ -1,32 +0,0 @@ -# - Try to find tvmet headers -# Once done this will define -# -# TVMET_FOUND - system has tvmet lib -# TVMET_INCLUDE_DIR - the tvmet include directory -# -# Copyright (C) 2008 Gael Guennebaud -# Adapted from FindEigen.cmake: -# Copyright (c) 2006, 2007 Montel Laurent, -# Redistribution and use is allowed according to the terms of the BSD license. -# For details see the accompanying COPYING-CMAKE-SCRIPTS file. - -if (TVMET_INCLUDE_DIR) - - # in cache already - set(TVMET_FOUND TRUE) - -else (TVMET_INCLUDE_DIR) - -find_path(TVMET_INCLUDE_DIR NAMES tvmet/tvmet.h - PATHS - ${TVMETDIR}/ - ${INCLUDE_INSTALL_DIR} - ) - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(Tvmet DEFAULT_MSG TVMET_INCLUDE_DIR) - -mark_as_advanced(TVMET_INCLUDE_DIR) - -endif(TVMET_INCLUDE_DIR) - diff --git a/eigen3/bench/btl/cmake/MacroOptionalAddSubdirectory.cmake b/eigen3/bench/btl/cmake/MacroOptionalAddSubdirectory.cmake deleted file mode 100644 --- a/eigen3/bench/btl/cmake/MacroOptionalAddSubdirectory.cmake +++ /dev/null @@ -1,31 +0,0 @@ -# - MACRO_OPTIONAL_ADD_SUBDIRECTORY() combines ADD_SUBDIRECTORY() with an OPTION() -# MACRO_OPTIONAL_ADD_SUBDIRECTORY( ) -# If you use MACRO_OPTIONAL_ADD_SUBDIRECTORY() instead of ADD_SUBDIRECTORY(), -# this will have two effects -# 1 - CMake will not complain if the directory doesn't exist -# This makes sense if you want to distribute just one of the subdirs -# in a source package, e.g. just one of the subdirs in kdeextragear. -# 2 - If the directory exists, it will offer an option to skip the -# subdirectory. -# This is useful if you want to compile only a subset of all -# directories. - -# Copyright (c) 2007, Alexander Neundorf, -# -# Redistribution and use is allowed according to the terms of the BSD license. -# For details see the accompanying COPYING-CMAKE-SCRIPTS file. - - -MACRO (MACRO_OPTIONAL_ADD_SUBDIRECTORY _dir ) - GET_FILENAME_COMPONENT(_fullPath ${_dir} ABSOLUTE) - IF(EXISTS ${_fullPath}) - IF(${ARGC} EQUAL 2) - OPTION(BUILD_${_dir} "Build directory ${_dir}" ${ARGV1}) - ELSE(${ARGC} EQUAL 2) - OPTION(BUILD_${_dir} "Build directory ${_dir}" TRUE) - ENDIF(${ARGC} EQUAL 2) - IF(BUILD_${_dir}) - ADD_SUBDIRECTORY(${_dir}) - ENDIF(BUILD_${_dir}) - ENDIF(EXISTS ${_fullPath}) -ENDMACRO (MACRO_OPTIONAL_ADD_SUBDIRECTORY) diff --git a/eigen3/bench/btl/data/CMakeLists.txt b/eigen3/bench/btl/data/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/data/CMakeLists.txt +++ /dev/null @@ -1,32 +0,0 @@ - -ADD_CUSTOM_TARGET(copy_scripts) - -SET(script_files go_mean mk_mean_script.sh mk_new_gnuplot.sh - perlib_plot_settings.txt action_settings.txt gnuplot_common_settings.hh ) - -FOREACH(script_file ${script_files}) -ADD_CUSTOM_COMMAND( - TARGET copy_scripts - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${script_file} ${CMAKE_CURRENT_BINARY_DIR}/ - ARGS -) -ENDFOREACH(script_file) - -ADD_CUSTOM_COMMAND( - TARGET copy_scripts - POST_BUILD - COMMAND ${CMAKE_CXX_COMPILER} --version | head -n 1 > ${CMAKE_CURRENT_BINARY_DIR}/compiler_version.txt - ARGS -) -ADD_CUSTOM_COMMAND( - TARGET copy_scripts - POST_BUILD - COMMAND echo "${Eigen_SOURCE_DIR}" > ${CMAKE_CURRENT_BINARY_DIR}/eigen_root_dir.txt - ARGS -) - -add_executable(smooth smooth.cxx) -add_executable(regularize regularize.cxx) -add_executable(main mean.cxx) -add_dependencies(main copy_scripts) diff --git a/eigen3/bench/btl/data/action_settings.txt b/eigen3/bench/btl/data/action_settings.txt deleted file mode 100644 --- a/eigen3/bench/btl/data/action_settings.txt +++ /dev/null @@ -1,19 +0,0 @@ -aat ; "{/*1.5 A x A^T}" ; "matrix size" ; 4:3000 -ata ; "{/*1.5 A^T x A}" ; "matrix size" ; 4:3000 -atv ; "{/*1.5 matrix^T x vector}" ; "matrix size" ; 4:3000 -axpby ; "{/*1.5 Y = alpha X + beta Y}" ; "vector size" ; 5:1000000 -axpy ; "{/*1.5 Y += alpha X}" ; "vector size" ; 5:1000000 -matrix_matrix ; "{/*1.5 matrix matrix product}" ; "matrix size" ; 4:3000 -matrix_vector ; "{/*1.5 matrix vector product}" ; "matrix size" ; 4:3000 -trmm ; "{/*1.5 triangular matrix matrix product}" ; "matrix size" ; 4:3000 -trisolve_vector ; "{/*1.5 triangular solver - vector (X = inv(L) X)}" ; "size" ; 4:3000 -trisolve_matrix ; "{/*1.5 triangular solver - matrix (M = inv(L) M)}" ; "size" ; 4:3000 -cholesky ; "{/*1.5 Cholesky decomposition}" ; "matrix size" ; 4:3000 -complete_lu_decomp ; "{/*1.5 Complete LU decomposition}" ; "matrix size" ; 4:3000 -partial_lu_decomp ; "{/*1.5 Partial LU decomposition}" ; "matrix size" ; 4:3000 -tridiagonalization ; "{/*1.5 Tridiagonalization}" ; "matrix size" ; 4:3000 -hessenberg ; "{/*1.5 Hessenberg decomposition}" ; "matrix size" ; 4:3000 -symv ; "{/*1.5 symmetric matrix vector product}" ; "matrix size" ; 4:3000 -syr2 ; "{/*1.5 symmretric rank-2 update (A += u^T v + u v^T)}" ; "matrix size" ; 4:3000 -ger ; "{/*1.5 general rank-1 update (A += u v^T)}" ; "matrix size" ; 4:3000 -rot ; "{/*1.5 apply rotation in the plane}" ; "vector size" ; 4:1000000 diff --git a/eigen3/bench/btl/data/gnuplot_common_settings.hh b/eigen3/bench/btl/data/gnuplot_common_settings.hh deleted file mode 100644 --- a/eigen3/bench/btl/data/gnuplot_common_settings.hh +++ /dev/null @@ -1,87 +0,0 @@ -set noclip points -set clip one -set noclip two -set bar 1.000000 -set border 31 lt -1 lw 1.000 -set xdata -set ydata -set zdata -set x2data -set y2data -set boxwidth -set dummy x,y -set format x "%g" -set format y "%g" -set format x2 "%g" -set format y2 "%g" -set format z "%g" -set angles radians -set nogrid -set key title "" -set key left top Right noreverse box linetype -2 linewidth 1.000 samplen 4 spacing 1 width 0 -set nolabel -set noarrow -# set nolinestyle # deprecated -set nologscale -set logscale x 10 -set offsets 0, 0, 0, 0 -set pointsize 1 -set encoding default -set nopolar -set noparametric -set view 60, 30, 1, 1 -set samples 100, 100 -set isosamples 10, 10 -set surface -set nocontour -set clabel '%8.3g' -set mapping cartesian -set nohidden3d -set cntrparam order 4 -set cntrparam linear -set cntrparam levels auto 5 -set cntrparam points 5 -set size ratio 0 1,1 -set origin 0,0 -# set data style lines -# set function style lines -set xzeroaxis lt -2 lw 1.000 -set x2zeroaxis lt -2 lw 1.000 -set yzeroaxis lt -2 lw 1.000 -set y2zeroaxis lt -2 lw 1.000 -set tics in -set ticslevel 0.5 -set tics scale 1, 0.5 -set mxtics default -set mytics default -set mx2tics default -set my2tics default -set xtics border mirror norotate autofreq -set ytics border mirror norotate autofreq -set ztics border nomirror norotate autofreq -set nox2tics -set noy2tics -set timestamp "" bottom norotate offset 0,0 -set rrange [ * : * ] noreverse nowriteback # (currently [-0:10] ) -set trange [ * : * ] noreverse nowriteback # (currently [-5:5] ) -set urange [ * : * ] noreverse nowriteback # (currently [-5:5] ) -set vrange [ * : * ] noreverse nowriteback # (currently [-5:5] ) -set xlabel "matrix size" offset 0,0 -set x2label "" offset 0,0 -set timefmt "%d/%m/%y\n%H:%M" -set xrange [ 10 : 1000 ] noreverse nowriteback -set x2range [ * : * ] noreverse nowriteback # (currently [-10:10] ) -set ylabel "MFLOPS" offset 0,0 -set y2label "" offset 0,0 -set yrange [ * : * ] noreverse nowriteback # (currently [-10:10] ) -set y2range [ * : * ] noreverse nowriteback # (currently [-10:10] ) -set zlabel "" offset 0,0 -set zrange [ * : * ] noreverse nowriteback # (currently [-10:10] ) -set zero 1e-08 -set lmargin -1 -set bmargin -1 -set rmargin -1 -set tmargin -1 -set locale "C" -set xrange [4:1024] - diff --git a/eigen3/bench/btl/data/go_mean b/eigen3/bench/btl/data/go_mean deleted file mode 100644 --- a/eigen3/bench/btl/data/go_mean +++ /dev/null @@ -1,58 +0,0 @@ -#!/bin/bash - -if [ $# < 1 ]; then - echo "Usage: $0 working_directory [tiny|large [prefix]]" -else - -mkdir -p $1 -##cp ../libs/*/*.dat $1 - -mode=large -if [ $# > 2 ]; then - mode=$2 -fi -if [ $# > 3 ]; then - prefix=$3 -fi - -EIGENDIR=`cat eigen_root_dir.txt` - -webpagefilename=$1/index.html -meanstatsfilename=$1/mean.html - -echo '' > $meanstatsfilename -echo '' > $webpagefilename -echo '

Configuration' >> $webpagefilename -echo '

    '\ - '
  • ' `cat /proc/cpuinfo | grep "model name" | head -n 1`\ - ' (' `uname -m` ')
    • '\ - '
  • compiler: ' `cat compiler_version.txt` '
    • '\ - '
  • eigen3: ' `hg identify -i $EIGENDIR` '
    • '\ - '
' \ - '

' >> $webpagefilename - -source mk_mean_script.sh axpy $1 11 2500 100000 250000 $mode $prefix -source mk_mean_script.sh axpby $1 11 2500 100000 250000 $mode $prefix -source mk_mean_script.sh matrix_vector $1 11 50 300 1000 $mode $prefix -source mk_mean_script.sh atv $1 11 50 300 1000 $mode $prefix -source mk_mean_script.sh matrix_matrix $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh aat $1 11 100 300 1000 $mode $prefix -# source mk_mean_script.sh ata $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh trmm $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh trisolve_vector $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh trisolve_matrix $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh cholesky $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh partial_lu_decomp $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh tridiagonalization $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh hessenberg $1 11 100 300 1000 $mode $prefix -source mk_mean_script.sh symv $1 11 50 300 1000 $mode $prefix -source mk_mean_script.sh syr2 $1 11 50 300 1000 $mode $prefix -source mk_mean_script.sh ger $1 11 50 300 1000 $mode $prefix -source mk_mean_script.sh rot $1 11 2500 100000 250000 $mode $prefix -source mk_mean_script.sh complete_lu_decomp $1 11 100 300 1000 $mode $prefix - -fi - -## compile the web page ## - -#echo `cat footer.html` >> $webpagefilename diff --git a/eigen3/bench/btl/data/mean.cxx b/eigen3/bench/btl/data/mean.cxx deleted file mode 100644 --- a/eigen3/bench/btl/data/mean.cxx +++ /dev/null @@ -1,182 +0,0 @@ -//===================================================== -// File : mean.cxx -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:15 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include -#include -#include -#include -#include "bench_parameter.hh" -#include "utils/xy_file.hh" -#include - -using namespace std; - -double mean_calc(const vector & tab_sizes, const vector & tab_mflops, const int size_min, const int size_max); - -class Lib_Mean{ - -public: - Lib_Mean( void ):_lib_name(),_mean_in_cache(),_mean_out_of_cache(){ - MESSAGE("Lib_mean Default Ctor"); - MESSAGE("!!! should not be used"); - exit(0); - } - Lib_Mean(const string & name, const double & mic, const double & moc):_lib_name(name),_mean_in_cache(mic),_mean_out_of_cache(moc){ - MESSAGE("Lib_mean Ctor"); - } - Lib_Mean(const Lib_Mean & lm):_lib_name(lm._lib_name),_mean_in_cache(lm._mean_in_cache),_mean_out_of_cache(lm._mean_out_of_cache){ - MESSAGE("Lib_mean Copy Ctor"); - } - ~Lib_Mean( void ){ - MESSAGE("Lib_mean Dtor"); - } - - double _mean_in_cache; - double _mean_out_of_cache; - string _lib_name; - - bool operator < ( const Lib_Mean &right) const - { - //return ( this->_mean_out_of_cache > right._mean_out_of_cache) ; - return ( this->_mean_in_cache > right._mean_in_cache) ; - } - -}; - - -int main( int argc , char *argv[] ) -{ - - if (argc<6){ - INFOS("!!! Error ... usage : main what mic Mic moc Moc filename1 finename2..."); - exit(0); - } - INFOS(argc); - - int min_in_cache=atoi(argv[2]); - int max_in_cache=atoi(argv[3]); - int min_out_of_cache=atoi(argv[4]); - int max_out_of_cache=atoi(argv[5]); - - - multiset s_lib_mean ; - - for (int i=6;i tab_sizes; - vector tab_mflops; - - read_xy_file(filename,tab_sizes,tab_mflops); - - mic=mean_calc(tab_sizes,tab_mflops,min_in_cache,max_in_cache); - moc=mean_calc(tab_sizes,tab_mflops,min_out_of_cache,max_out_of_cache); - - Lib_Mean cur_lib_mean(filename,mic,moc); - - s_lib_mean.insert(cur_lib_mean); - - } - - } - - - cout << "" << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - - multiset::iterator is = s_lib_mean.begin(); - Lib_Mean best(*is); - - - for (is=s_lib_mean.begin(); is!=s_lib_mean.end() ; is++){ - - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - cout << " " << endl ; - - } - - cout << "
" << argv[1] << " in cache
mean perf
Mflops 		in cache
% best 		out of cache
mean perf
Mflops 		out of cache
% best 		details comments
" << is->_lib_name << " " << is->_mean_in_cache << " " << 100*(is->_mean_in_cache/best._mean_in_cache) << " " << is->_mean_out_of_cache << " " << 100*(is->_mean_out_of_cache/best._mean_out_of_cache) << " " << - "_lib_name<<"_"<snippet/" - "_lib_name<<"_flags\">flags " << - "_lib_name<<"_comments\">click here
" << endl ; - - ofstream output_file ("../order_lib",ios::out) ; - - for (is=s_lib_mean.begin(); is!=s_lib_mean.end() ; is++){ - output_file << is->_lib_name << endl ; - } - - output_file.close(); - -} - -double mean_calc(const vector & tab_sizes, const vector & tab_mflops, const int size_min, const int size_max){ - - int size=tab_sizes.size(); - int nb_sample=0; - double mean=0.0; - - for (int i=0;i=size_min)&&(tab_sizes[i]<=size_max)){ - - nb_sample++; - mean+=tab_mflops[i]; - - } - - - } - - if (nb_sample==0){ - INFOS("no data for mean calculation"); - return 0.0; - } - - return mean/nb_sample; -} - - - - diff --git a/eigen3/bench/btl/data/mk_gnuplot_script.sh b/eigen3/bench/btl/data/mk_gnuplot_script.sh deleted file mode 100644 --- a/eigen3/bench/btl/data/mk_gnuplot_script.sh +++ /dev/null @@ -1,68 +0,0 @@ -#! /bin/bash -WHAT=$1 -DIR=$2 -echo $WHAT script generation -cat $WHAT.hh > $WHAT.gnuplot - -DATA_FILE=`find $DIR -name "*.dat" | grep $WHAT` - -echo plot \\ >> $WHAT.gnuplot - -for FILE in $DATA_FILE -do - LAST=$FILE -done - -echo LAST=$LAST - -for FILE in $DATA_FILE -do - if [ $FILE != $LAST ] - then - BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} - echo "'"$FILE"'" title "'"$TITLE"'" ",\\" >> $WHAT.gnuplot - fi -done -BASE=${LAST##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} -echo "'"$LAST"'" title "'"$TITLE"'" >> $WHAT.gnuplot - -#echo set term postscript color >> $WHAT.gnuplot -#echo set output "'"$WHAT.ps"'" >> $WHAT.gnuplot -echo set term pbm small color >> $WHAT.gnuplot -echo set output "'"$WHAT.ppm"'" >> $WHAT.gnuplot -echo plot \\ >> $WHAT.gnuplot - -for FILE in $DATA_FILE -do - if [ $FILE != $LAST ] - then - BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} - echo "'"$FILE"'" title "'"$TITLE"'" ",\\" >> $WHAT.gnuplot - fi -done -BASE=${LAST##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} -echo "'"$LAST"'" title "'"$TITLE"'" >> $WHAT.gnuplot - -echo set term jpeg large >> $WHAT.gnuplot -echo set output "'"$WHAT.jpg"'" >> $WHAT.gnuplot -echo plot \\ >> $WHAT.gnuplot - -for FILE in $DATA_FILE -do - if [ $FILE != $LAST ] - then - BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} - echo "'"$FILE"'" title "'"$TITLE"'" ",\\" >> $WHAT.gnuplot - fi -done -BASE=${LAST##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} -echo "'"$LAST"'" title "'"$TITLE"'" >> $WHAT.gnuplot - - -gnuplot -persist < $WHAT.gnuplot - -rm $WHAT.gnuplot - - - - diff --git a/eigen3/bench/btl/data/mk_mean_script.sh b/eigen3/bench/btl/data/mk_mean_script.sh deleted file mode 100644 --- a/eigen3/bench/btl/data/mk_mean_script.sh +++ /dev/null @@ -1,52 +0,0 @@ -#! /bin/bash -WHAT=$1 -DIR=$2 -MINIC=$3 -MAXIC=$4 -MINOC=$5 -MAXOC=$6 -prefix=$8 - -meanstatsfilename=$2/mean.html - -WORK_DIR=tmp -mkdir $WORK_DIR - -DATA_FILE=`find $DIR -name "*.dat" | grep _${WHAT}` - -if [ -n "$DATA_FILE" ]; then - - echo "" - echo "$1..." - for FILE in $DATA_FILE - do - ##echo hello world - ##echo "mk_mean_script1" ${FILE} - BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} - - ##echo "mk_mean_script1" ${TITLE} - cp $FILE ${WORK_DIR}/${TITLE} - - done - - cd $WORK_DIR - ../main $1 $3 $4 $5 $6 * >> ../$meanstatsfilename - ../mk_new_gnuplot.sh $1 $2 $7 - rm -f *.gnuplot - cd .. - - echo '
' >> $meanstatsfilename - - webpagefilename=$2/index.html - # echo '

'${WHAT}'

' >> $webpagefilename - echo '
'${WHAT}'
' >> $webpagefilename - -fi - -rm -R $WORK_DIR - - - - - - diff --git a/eigen3/bench/btl/data/mk_new_gnuplot.sh b/eigen3/bench/btl/data/mk_new_gnuplot.sh deleted file mode 100644 --- a/eigen3/bench/btl/data/mk_new_gnuplot.sh +++ /dev/null @@ -1,54 +0,0 @@ -#!/bin/bash -WHAT=$1 -DIR=$2 - -cat ../gnuplot_common_settings.hh > ${WHAT}.gnuplot - -echo "set title " `grep ${WHAT} ../action_settings.txt | head -n 1 | cut -d ";" -f 2` >> $WHAT.gnuplot -echo "set xlabel " `grep ${WHAT} ../action_settings.txt | head -n 1 | cut -d ";" -f 3` " offset 0,0" >> $WHAT.gnuplot -echo "set xrange [" `grep ${WHAT} ../action_settings.txt | head -n 1 | cut -d ";" -f 4` "]" >> $WHAT.gnuplot - -if [ $# > 3 ]; then - if [ "$3" == "tiny" ]; then - echo "set xrange [2:16]" >> $WHAT.gnuplot - echo "set nologscale" >> $WHAT.gnuplot - fi -fi - - - -DATA_FILE=`cat ../order_lib` -echo set term postscript color rounded enhanced >> $WHAT.gnuplot -echo set output "'"../${DIR}/$WHAT.ps"'" >> $WHAT.gnuplot - -# echo set term svg color rounded enhanced >> $WHAT.gnuplot -# echo "set terminal svg enhanced size 1000 1000 fname \"Times\" fsize 36" >> $WHAT.gnuplot -# echo set output "'"../${DIR}/$WHAT.svg"'" >> $WHAT.gnuplot - -echo plot \\ >> $WHAT.gnuplot - -for FILE in $DATA_FILE -do - LAST=$FILE -done - -for FILE in $DATA_FILE -do - BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} - - echo "'"$FILE"'" `grep $TITLE ../perlib_plot_settings.txt | head -n 1 | cut -d ";" -f 2` "\\" >> $WHAT.gnuplot - if [ $FILE != $LAST ] - then - echo ", \\" >> $WHAT.gnuplot - fi -done -echo " " >> $WHAT.gnuplot - -gnuplot -persist < $WHAT.gnuplot - -rm $WHAT.gnuplot - -ps2pdf ../${DIR}/$WHAT.ps ../${DIR}/$WHAT.pdf -convert -background white -density 120 -rotate 90 -resize 800 +dither -colors 256 -quality 0 ../${DIR}/$WHAT.ps -background white -flatten ../${DIR}/$WHAT.png - -# pstoedit -rotate -90 -xscale 0.8 -yscale 0.8 -centered -yshift -50 -xshift -100 -f plot-svg aat.ps aat2.svg diff --git a/eigen3/bench/btl/data/perlib_plot_settings.txt b/eigen3/bench/btl/data/perlib_plot_settings.txt deleted file mode 100644 --- a/eigen3/bench/btl/data/perlib_plot_settings.txt +++ /dev/null @@ -1,16 +0,0 @@ -eigen3 ; with lines lw 4 lt 1 lc rgbcolor "black" -eigen2 ; with lines lw 3 lt 1 lc rgbcolor "#999999" -EigenBLAS ; with lines lw 3 lt 3 lc rgbcolor "#999999" -eigen3_novec ; with lines lw 2 lt 1 lc rgbcolor "#999999" -eigen3_nogccvec ; with lines lw 2 lt 2 lc rgbcolor "#991010" -INTEL_MKL ; with lines lw 3 lt 1 lc rgbcolor "#ff0000" -ATLAS ; with lines lw 3 lt 1 lc rgbcolor "#008000" -gmm ; with lines lw 3 lt 1 lc rgbcolor "#0000ff" -ublas ; with lines lw 3 lt 1 lc rgbcolor "#00b7ff" -mtl4 ; with lines lw 3 lt 1 lc rgbcolor "#d18847" -blitz ; with lines lw 3 lt 1 lc rgbcolor "#ff00ff" -F77 ; with lines lw 3 lt 3 lc rgbcolor "#e6e64c" -GOTO ; with lines lw 3 lt 3 lc rgbcolor "#C05600" -GOTO2 ; with lines lw 3 lt 1 lc rgbcolor "#C05600" -C ; with lines lw 3 lt 3 lc rgbcolor "#e6bd96" -ACML ; with lines lw 2 lt 3 lc rgbcolor "#e6e64c" diff --git a/eigen3/bench/btl/data/regularize.cxx b/eigen3/bench/btl/data/regularize.cxx deleted file mode 100644 --- a/eigen3/bench/btl/data/regularize.cxx +++ /dev/null @@ -1,131 +0,0 @@ -//===================================================== -// File : regularize.cxx -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:15 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include -#include -#include -#include -#include "bench_parameter.hh" -#include - -using namespace std; - -void read_xy_file(const string & filename, vector & tab_sizes, vector & tab_mflops); -void regularize_curve(const string & filename, - const vector & tab_mflops, - const vector & tab_sizes, - int start_cut_size, int stop_cut_size); -///////////////////////////////////////////////////////////////////////////////////////////////// - -int main( int argc , char *argv[] ) -{ - - // input data - - if (argc<4){ - INFOS("!!! Error ... usage : main filename start_cut_size stop_cut_size regularize_filename"); - exit(0); - } - INFOS(argc); - - int start_cut_size=atoi(argv[2]); - int stop_cut_size=atoi(argv[3]); - - string filename=argv[1]; - string regularize_filename=argv[4]; - - INFOS(filename); - INFOS("start_cut_size="< tab_sizes; - vector tab_mflops; - - read_xy_file(filename,tab_sizes,tab_mflops); - - // regularizeing - - regularize_curve(regularize_filename,tab_mflops,tab_sizes,start_cut_size,stop_cut_size); - - -} - -////////////////////////////////////////////////////////////////////////////////////// - -void regularize_curve(const string & filename, - const vector & tab_mflops, - const vector & tab_sizes, - int start_cut_size, int stop_cut_size) -{ - int size=tab_mflops.size(); - ofstream output_file (filename.c_str(),ios::out) ; - - int i=0; - - while(tab_sizes[i] & tab_sizes, vector & tab_mflops){ - - ifstream input_file (filename.c_str(),ios::in) ; - - if (!input_file){ - INFOS("!!! Error opening "<> size >> mflops ){ - nb_point++; - tab_sizes.push_back(size); - tab_mflops.push_back(mflops); - } - SCRUTE(nb_point); - - input_file.close(); -} - diff --git a/eigen3/bench/btl/data/smooth.cxx b/eigen3/bench/btl/data/smooth.cxx deleted file mode 100644 --- a/eigen3/bench/btl/data/smooth.cxx +++ /dev/null @@ -1,198 +0,0 @@ -//===================================================== -// File : smooth.cxx -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:15 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include -#include -#include -#include -#include -#include "bench_parameter.hh" -#include - -using namespace std; - -void read_xy_file(const string & filename, vector & tab_sizes, vector & tab_mflops); -void write_xy_file(const string & filename, vector & tab_sizes, vector & tab_mflops); -void smooth_curve(const vector & tab_mflops, vector & smooth_tab_mflops,int window_half_width); -void centered_smooth_curve(const vector & tab_mflops, vector & smooth_tab_mflops,int window_half_width); - -///////////////////////////////////////////////////////////////////////////////////////////////// - -int main( int argc , char *argv[] ) -{ - - // input data - - if (argc<3){ - INFOS("!!! Error ... usage : main filename window_half_width smooth_filename"); - exit(0); - } - INFOS(argc); - - int window_half_width=atoi(argv[2]); - - string filename=argv[1]; - string smooth_filename=argv[3]; - - INFOS(filename); - INFOS("window_half_width="< tab_sizes; - vector tab_mflops; - - read_xy_file(filename,tab_sizes,tab_mflops); - - // smoothing - - vector smooth_tab_mflops; - - //smooth_curve(tab_mflops,smooth_tab_mflops,window_half_width); - centered_smooth_curve(tab_mflops,smooth_tab_mflops,window_half_width); - - // output result - - write_xy_file(smooth_filename,tab_sizes,smooth_tab_mflops); - - -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -template -double weighted_mean(const VECTOR & data) -{ - - double mean=0.0; - - for (int i=0 ; i & tab_mflops, vector & smooth_tab_mflops,int window_half_width){ - - int window_width=2*window_half_width+1; - - int size=tab_mflops.size(); - - vector sample(window_width); - - for (int i=0 ; i < size ; i++){ - - for ( int j=0 ; j < window_width ; j++ ){ - - int shifted_index=i+j-window_half_width; - if (shifted_index<0) shifted_index=0; - if (shifted_index>size-1) shifted_index=size-1; - sample[j]=tab_mflops[shifted_index]; - - } - - smooth_tab_mflops.push_back(weighted_mean(sample)); - - } - -} - -void centered_smooth_curve(const vector & tab_mflops, vector & smooth_tab_mflops,int window_half_width){ - - int max_window_width=2*window_half_width+1; - - int size=tab_mflops.size(); - - - for (int i=0 ; i < size ; i++){ - - deque sample; - - - sample.push_back(tab_mflops[i]); - - for ( int j=1 ; j <= window_half_width ; j++ ){ - - int before=i-j; - int after=i+j; - - if ((before>=0)&&(after & tab_sizes, vector & tab_mflops){ - - ofstream output_file (filename.c_str(),ios::out) ; - - for (int i=0 ; i < tab_sizes.size() ; i++) - { - output_file << tab_sizes[i] << " " << tab_mflops[i] << endl ; - } - - output_file.close(); - -} - - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -void read_xy_file(const string & filename, vector & tab_sizes, vector & tab_mflops){ - - ifstream input_file (filename.c_str(),ios::in) ; - - if (!input_file){ - INFOS("!!! Error opening "<> size >> mflops ){ - nb_point++; - tab_sizes.push_back(size); - tab_mflops.push_back(mflops); - } - SCRUTE(nb_point); - - input_file.close(); -} - diff --git a/eigen3/bench/btl/data/smooth_all.sh b/eigen3/bench/btl/data/smooth_all.sh deleted file mode 100644 --- a/eigen3/bench/btl/data/smooth_all.sh +++ /dev/null @@ -1,68 +0,0 @@ -#! /bin/bash -ORIG_DIR=$1 -SMOOTH_DIR=${ORIG_DIR}_smooth -mkdir ${SMOOTH_DIR} - -AXPY_FILE=`find ${ORIG_DIR} -name "*.dat" | grep axpy` -for FILE in ${AXPY_FILE} -do - echo $FILE - BASE=${FILE##*/} - ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE}_tmp - ./regularize ${SMOOTH_DIR}/${BASE}_tmp 2500 15000 ${SMOOTH_DIR}/${BASE} - rm -f ${SMOOTH_DIR}/${BASE}_tmp -done - - -MATRIX_VECTOR_FILE=`find ${ORIG_DIR} -name "*.dat" | grep matrix_vector` -for FILE in ${MATRIX_VECTOR_FILE} -do - echo $FILE - BASE=${FILE##*/} - ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE}_tmp - ./regularize ${SMOOTH_DIR}/${BASE}_tmp 50 180 ${SMOOTH_DIR}/${BASE} - rm -f ${SMOOTH_DIR}/${BASE}_tmp -done - -MATRIX_MATRIX_FILE=`find ${ORIG_DIR} -name "*.dat" | grep matrix_matrix` -for FILE in ${MATRIX_MATRIX_FILE} -do - echo $FILE - BASE=${FILE##*/} - ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE} -done - -AAT_FILE=`find ${ORIG_DIR} -name "*.dat" | grep _aat` -for FILE in ${AAT_FILE} -do - echo $FILE - BASE=${FILE##*/} - ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE} -done - - -ATA_FILE=`find ${ORIG_DIR} -name "*.dat" | grep _ata` -for FILE in ${ATA_FILE} -do - echo $FILE - BASE=${FILE##*/} - ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE} -done - -### no smoothing for tinyvector and matrices libs - -TINY_BLITZ_FILE=`find ${ORIG_DIR} -name "*.dat" | grep tiny_blitz` -for FILE in ${TINY_BLITZ_FILE} -do - echo $FILE - BASE=${FILE##*/} - cp ${ORIG_DIR}/${BASE} ${SMOOTH_DIR}/${BASE} -done - -TVMET_FILE=`find ${ORIG_DIR} -name "*.dat" | grep tvmet` -for FILE in ${TVMET_FILE} -do - echo $FILE - BASE=${FILE##*/} - cp ${ORIG_DIR}/${BASE} ${SMOOTH_DIR}/${BASE} -done diff --git a/eigen3/bench/btl/generic_bench/bench.hh b/eigen3/bench/btl/generic_bench/bench.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/bench.hh +++ /dev/null @@ -1,168 +0,0 @@ -//===================================================== -// File : bench.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:16 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BENCH_HH -#define BENCH_HH - -#include "btl.hh" -#include "bench_parameter.hh" -#include -#include "utilities.h" -#include "size_lin_log.hh" -#include "xy_file.hh" -#include -#include -#include "timers/portable_perf_analyzer.hh" -// #include "timers/mixed_perf_analyzer.hh" -// #include "timers/x86_perf_analyzer.hh" -// #include "timers/STL_perf_analyzer.hh" -#ifdef HAVE_MKL -extern "C" void cblas_saxpy(const int, const float, const float*, const int, float *, const int); -#endif -using namespace std; - -template class Perf_Analyzer, class Action> -BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point ) -{ - if (BtlConfig::skipAction(Action::name())) - return; - - string filename="bench_"+Action::name()+".dat"; - - INFOS("starting " < tab_mflops(nb_point); - std::vector tab_sizes(nb_point); - - // matrices and vector size calculations - size_lin_log(nb_point,size_min,size_max,tab_sizes); - - std::vector oldSizes; - std::vector oldFlops; - bool hasOldResults = read_xy_file(filename, oldSizes, oldFlops, true); - int oldi = oldSizes.size() - 1; - - // loop on matrix size - Perf_Analyzer perf_action; - for (int i=nb_point-1;i>=0;i--) - { - //INFOS("size=" <=0 && oldSizes[oldi]>tab_sizes[i]) - --oldi; - if (oldi>=0 && oldSizes[oldi]==tab_sizes[i]) - { - if (oldFlops[oldi] "; - else - std::cout << "\t < "; - std::cout << oldFlops[oldi]; - } - --oldi; - } - std::cout << " MFlops (" << nb_point-i << "/" << nb_point << ")" << std::endl; - } - - if (!BtlConfig::Instance.overwriteResults) - { - if (hasOldResults) - { - // merge the two data - std::vector newSizes; - std::vector newFlops; - int i=0; - int j=0; - while (i -BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point ){ - - // if the rdtsc is not available : - bench(size_min,size_max,nb_point); - // if the rdtsc is available : -// bench(size_min,size_max,nb_point); - - - // Only for small problem size. Otherwize it will be too long -// bench(size_min,size_max,nb_point); -// bench(size_min,size_max,nb_point); - -} - -#endif diff --git a/eigen3/bench/btl/generic_bench/bench_parameter.hh b/eigen3/bench/btl/generic_bench/bench_parameter.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/bench_parameter.hh +++ /dev/null @@ -1,53 +0,0 @@ -//===================================================== -// File : bench_parameter.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:16 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BENCH_PARAMETER_HH -#define BENCH_PARAMETER_HH - -// minimal time for each measurement -#define REAL_TYPE float -// minimal time for each measurement -#define MIN_TIME 0.2 -// nb of point on bench curves -#define NB_POINT 100 -// min vector size for axpy bench -#define MIN_AXPY 5 -// max vector size for axpy bench -#define MAX_AXPY 1000000 -// min matrix size for matrix vector product bench -#define MIN_MV 5 -// max matrix size for matrix vector product bench -#define MAX_MV 3000 -// min matrix size for matrix matrix product bench -#define MIN_MM 5 -// max matrix size for matrix matrix product bench -#define MAX_MM MAX_MV -// min matrix size for LU bench -#define MIN_LU 5 -// max matrix size for LU bench -#define MAX_LU 3000 -// max size for tiny vector and matrix -#define TINY_MV_MAX_SIZE 16 -// default nb_sample for x86 timer -#define DEFAULT_NB_SAMPLE 1000 - -// how many times we run a single bench (keep the best perf) -#define DEFAULT_NB_TRIES 3 - -#endif diff --git a/eigen3/bench/btl/generic_bench/btl.hh b/eigen3/bench/btl/generic_bench/btl.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/btl.hh +++ /dev/null @@ -1,247 +0,0 @@ -//===================================================== -// File : btl.hh -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BTL_HH -#define BTL_HH - -#include "bench_parameter.hh" -#include -#include -#include -#include -#include "utilities.h" - -#if (defined __GNUC__) -#define BTL_ALWAYS_INLINE __attribute__((always_inline)) inline -#else -#define BTL_ALWAYS_INLINE inline -#endif - -#if (defined __GNUC__) -#define BTL_DONT_INLINE __attribute__((noinline)) -#else -#define BTL_DONT_INLINE -#endif - -#if (defined __GNUC__) -#define BTL_ASM_COMMENT(X) asm("#" X) -#else -#define BTL_ASM_COMMENT(X) -#endif - -#if (defined __GNUC__) && (!defined __INTEL_COMPILER) && !defined(__arm__) && !defined(__powerpc__) -#define BTL_DISABLE_SSE_EXCEPTIONS() { \ - int aux; \ - asm( \ - "stmxcsr %[aux] \n\t" \ - "orl $32832, %[aux] \n\t" \ - "ldmxcsr %[aux] \n\t" \ - : : [aux] "m" (aux)); \ -} -#else -#define BTL_DISABLE_SSE_EXCEPTIONS() -#endif - -/** Enhanced std::string -*/ -class BtlString : public std::string -{ -public: - BtlString() : std::string() {} - BtlString(const BtlString& str) : std::string(static_cast(str)) {} - BtlString(const std::string& str) : std::string(str) {} - BtlString(const char* str) : std::string(str) {} - - operator const char* () const { return c_str(); } - - void trim( bool left = true, bool right = true ) - { - int lspaces, rspaces, len = length(), i; - lspaces = rspaces = 0; - - if ( left ) - for (i=0; i=0 && (at(i)==' '||at(i)=='\t'||at(i)=='\r'||at(i)=='\n'); rspaces++,i--); - - *this = substr(lspaces, len-lspaces-rspaces); - } - - std::vector split( const BtlString& delims = "\t\n ") const - { - std::vector ret; - unsigned int numSplits = 0; - size_t start, pos; - start = 0; - do - { - pos = find_first_of(delims, start); - if (pos == start) - { - ret.push_back(""); - start = pos + 1; - } - else if (pos == npos) - ret.push_back( substr(start) ); - else - { - ret.push_back( substr(start, pos - start) ); - start = pos + 1; - } - //start = find_first_not_of(delims, start); - ++numSplits; - } while (pos != npos); - return ret; - } - - bool endsWith(const BtlString& str) const - { - if(str.size()>this->size()) - return false; - return this->substr(this->size()-str.size(),str.size()) == str; - } - bool contains(const BtlString& str) const - { - return this->find(str)size(); - } - bool beginsWith(const BtlString& str) const - { - if(str.size()>this->size()) - return false; - return this->substr(0,str.size()) == str; - } - - BtlString toLowerCase( void ) - { - std::transform(begin(), end(), begin(), static_cast(::tolower) ); - return *this; - } - BtlString toUpperCase( void ) - { - std::transform(begin(), end(), begin(), static_cast(::toupper) ); - return *this; - } - - /** Case insensitive comparison. - */ - bool isEquiv(const BtlString& str) const - { - BtlString str0 = *this; - str0.toLowerCase(); - BtlString str1 = str; - str1.toLowerCase(); - return str0 == str1; - } - - /** Decompose the current string as a path and a file. - For instance: "dir1/dir2/file.ext" leads to path="dir1/dir2/" and filename="file.ext" - */ - void decomposePathAndFile(BtlString& path, BtlString& filename) const - { - std::vector elements = this->split("/\\"); - path = ""; - filename = elements.back(); - elements.pop_back(); - if (this->at(0)=='/') - path = "/"; - for (unsigned int i=0 ; i config = BtlString(_config).split(" \t\n"); - for (int i = 0; i m_selectedActionNames; -}; - -#define BTL_MAIN \ - BtlConfig BtlConfig::Instance - -#endif // BTL_HH diff --git a/eigen3/bench/btl/generic_bench/init/init_function.hh b/eigen3/bench/btl/generic_bench/init/init_function.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/init/init_function.hh +++ /dev/null @@ -1,54 +0,0 @@ -//===================================================== -// File : init_function.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:18 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef INIT_FUNCTION_HH -#define INIT_FUNCTION_HH - -double simple_function(int index) -{ - return index; -} - -double simple_function(int index_i, int index_j) -{ - return index_i+index_j; -} - -double pseudo_random(int index) -{ - return std::rand()/double(RAND_MAX); -} - -double pseudo_random(int index_i, int index_j) -{ - return std::rand()/double(RAND_MAX); -} - - -double null_function(int index) -{ - return 0.0; -} - -double null_function(int index_i, int index_j) -{ - return 0.0; -} - -#endif diff --git a/eigen3/bench/btl/generic_bench/init/init_matrix.hh b/eigen3/bench/btl/generic_bench/init/init_matrix.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/init/init_matrix.hh +++ /dev/null @@ -1,64 +0,0 @@ -//===================================================== -// File : init_matrix.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef INIT_MATRIX_HH -#define INIT_MATRIX_HH - -// The Vector class must satisfy the following part of STL vector concept : -// resize() method -// [] operator for setting element -// value_type defined -template -BTL_DONT_INLINE void init_row(Vector & X, int size, int row){ - - X.resize(size); - - for (int j=0;j -BTL_DONT_INLINE void init_matrix(Vector & A, int size){ - A.resize(size); - for (int row=0; row(A[row],size,row); - } -} - -template -BTL_DONT_INLINE void init_matrix_symm(Matrix& A, int size){ - A.resize(size); - for (int row=0; row -// Copyright (C) EDF R&D, lun sep 30 14:23:18 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef INIT_VECTOR_HH -#define INIT_VECTOR_HH - -// The Vector class must satisfy the following part of STL vector concept : -// resize() method -// [] operator for setting element -// value_type defined -template -void init_vector(Vector & X, int size){ - - X.resize(size); - - for (int i=0;i -// Copyright (C) EDF R&D, lun sep 30 14:23:16 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BENCH_STATIC_HH -#define BENCH_STATIC_HH - -#include "btl.hh" -#include "bench_parameter.hh" -#include -#include "utilities.h" -#include "xy_file.hh" -#include "static/static_size_generator.hh" -#include "timers/portable_perf_analyzer.hh" -// #include "timers/mixed_perf_analyzer.hh" -// #include "timers/x86_perf_analyzer.hh" - -using namespace std; - - -template class Perf_Analyzer, template class Action, template class Interface> -BTL_DONT_INLINE void bench_static(void) -{ - if (BtlConfig::skipAction(Action >::name())) - return; - - string filename = "bench_" + Action >::name() + ".dat"; - - INFOS("starting " << filename); - - const int max_size = TINY_MV_MAX_SIZE; - - std::vector tab_mflops; - std::vector tab_sizes; - - static_size_generator::go(tab_sizes,tab_mflops); - - dump_xy_file(tab_sizes,tab_mflops,filename); -} - -// default Perf Analyzer -template class Action, template class Interface> -BTL_DONT_INLINE void bench_static(void) -{ - bench_static(); - //bench_static(); - //bench_static(); -} - -#endif - - - - - - - - - - - - - - - diff --git a/eigen3/bench/btl/generic_bench/static/intel_bench_fixed_size.hh b/eigen3/bench/btl/generic_bench/static/intel_bench_fixed_size.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/static/intel_bench_fixed_size.hh +++ /dev/null @@ -1,66 +0,0 @@ -//===================================================== -// File : intel_bench_fixed_size.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, mar déc 3 18:59:37 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef _BENCH_FIXED_SIZE_HH_ -#define _BENCH_FIXED_SIZE_HH_ - -#include "utilities.h" -#include "function_time.hh" - -template -double bench_fixed_size(int size, unsigned long long & nb_calc,unsigned long long & nb_init) -{ - - Action action(size); - - double time_baseline=time_init(nb_init,action); - - while (time_baseline < MIN_TIME) { - - //INFOS("nb_init="< > > perf_action; - tab_mflops.push_back(perf_action.eval_mflops(SIZE)); - std::cout << tab_mflops.back() << " MFlops" << std::endl; - static_size_generator::go(tab_sizes,tab_mflops); - }; -}; - -//recursion end - -template class Perf_Analyzer, template class Action, template class Interface> -struct static_size_generator<1,Perf_Analyzer,Action,Interface>{ - static void go(vector & tab_sizes, vector & tab_mflops) - { - tab_sizes.push_back(1); - Perf_Analyzer > > perf_action; - tab_mflops.push_back(perf_action.eval_mflops(1)); - }; -}; - -#endif - - - - diff --git a/eigen3/bench/btl/generic_bench/timers/STL_perf_analyzer.hh b/eigen3/bench/btl/generic_bench/timers/STL_perf_analyzer.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/timers/STL_perf_analyzer.hh +++ /dev/null @@ -1,82 +0,0 @@ -//===================================================== -// File : STL_perf_analyzer.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, mar déc 3 18:59:35 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef _STL_PERF_ANALYSER_HH -#define _STL_PERF_ANALYSER_HH - -#include "STL_timer.hh" -#include "bench_parameter.hh" - -template -class STL_Perf_Analyzer{ -public: - STL_Perf_Analyzer(unsigned long long nb_sample=DEFAULT_NB_SAMPLE):_nb_sample(nb_sample),_chronos() - { - MESSAGE("STL_Perf_Analyzer Ctor"); - }; - STL_Perf_Analyzer( const STL_Perf_Analyzer & ){ - INFOS("Copy Ctor not implemented"); - exit(0); - }; - ~STL_Perf_Analyzer( void ){ - MESSAGE("STL_Perf_Analyzer Dtor"); - }; - - - inline double eval_mflops(int size) - { - - ACTION action(size); - - _chronos.start_baseline(_nb_sample); - - do { - - action.initialize(); - } while (_chronos.check()); - - double baseline_time=_chronos.get_time(); - - _chronos.start(_nb_sample); - do { - action.initialize(); - action.calculate(); - } while (_chronos.check()); - - double calculate_time=_chronos.get_time(); - - double corrected_time=calculate_time-baseline_time; - - // cout << size <<" "< -// Copyright (C) EDF R&D, mar déc 3 18:59:35 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -// STL Timer Class. Adapted (L.P.) from the timer class by Musser et Al -// described int the Book : STL Tutorial and reference guide. -// Define a timer class for analyzing algorithm performance. -#include -#include -#include -#include -#include -using namespace std; - -class STL_Timer { -public: - STL_Timer(){ baseline = false; }; // Default constructor - // Start a series of r trials: - void start(unsigned int r){ - reps = r; - count = 0; - iterations.clear(); - iterations.reserve(reps); - initial = time(0); - }; - // Start a series of r trials to determine baseline time: - void start_baseline(unsigned int r) - { - baseline = true; - start(r); - } - // Returns true if the trials have been completed, else false - bool check() - { - ++count; - final = time(0); - if (initial < final) { - iterations.push_back(count); - initial = final; - count = 0; - } - return (iterations.size() < reps); - }; - // Returns the results for external use - double get_time( void ) - { - sort(iterations.begin(), iterations.end()); - return 1.0/iterations[reps/2]; - }; -private: - unsigned int reps; // Number of trials - // For storing loop iterations of a trial - vector iterations; - // For saving initial and final times of a trial - time_t initial, final; - // For counting loop iterations of a trial - unsigned long count; - // true if this is a baseline computation, false otherwise - bool baseline; - // For recording the baseline time - double baseline_time; -}; - diff --git a/eigen3/bench/btl/generic_bench/timers/mixed_perf_analyzer.hh b/eigen3/bench/btl/generic_bench/timers/mixed_perf_analyzer.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/timers/mixed_perf_analyzer.hh +++ /dev/null @@ -1,73 +0,0 @@ -//===================================================== -// File : mixed_perf_analyzer.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, mar déc 3 18:59:36 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef _MIXED_PERF_ANALYSER_HH -#define _MIXED_PERF_ANALYSER_HH - -#include "x86_perf_analyzer.hh" -#include "portable_perf_analyzer.hh" - -// choose portable perf analyzer for long calculations and x86 analyser for short ones - - -template -class Mixed_Perf_Analyzer{ - -public: - Mixed_Perf_Analyzer( void ):_x86pa(),_ppa(),_use_ppa(true) - { - MESSAGE("Mixed_Perf_Analyzer Ctor"); - }; - Mixed_Perf_Analyzer( const Mixed_Perf_Analyzer & ){ - INFOS("Copy Ctor not implemented"); - exit(0); - }; - ~Mixed_Perf_Analyzer( void ){ - MESSAGE("Mixed_Perf_Analyzer Dtor"); - }; - - - inline double eval_mflops(int size) - { - - double result=0.0; - if (_use_ppa){ - result=_ppa.eval_mflops(size); - if (_ppa.get_nb_calc()>DEFAULT_NB_SAMPLE){_use_ppa=false;} - } - else{ - result=_x86pa.eval_mflops(size); - } - - return result; - } - -private: - - Portable_Perf_Analyzer _ppa; - X86_Perf_Analyzer _x86pa; - bool _use_ppa; - -}; - -#endif - - - - diff --git a/eigen3/bench/btl/generic_bench/timers/portable_perf_analyzer.hh b/eigen3/bench/btl/generic_bench/timers/portable_perf_analyzer.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/timers/portable_perf_analyzer.hh +++ /dev/null @@ -1,103 +0,0 @@ -//===================================================== -// File : portable_perf_analyzer.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef _PORTABLE_PERF_ANALYZER_HH -#define _PORTABLE_PERF_ANALYZER_HH - -#include "utilities.h" -#include "timers/portable_timer.hh" - -template -class Portable_Perf_Analyzer{ -public: - Portable_Perf_Analyzer( ):_nb_calc(0), m_time_action(0), _chronos(){ - MESSAGE("Portable_Perf_Analyzer Ctor"); - }; - Portable_Perf_Analyzer( const Portable_Perf_Analyzer & ){ - INFOS("Copy Ctor not implemented"); - exit(0); - }; - ~Portable_Perf_Analyzer(){ - MESSAGE("Portable_Perf_Analyzer Dtor"); - }; - - BTL_DONT_INLINE double eval_mflops(int size) - { - Action action(size); - -// action.initialize(); -// time_action = time_calculate(action); - while (m_time_action < MIN_TIME) - { - if(_nb_calc==0) _nb_calc = 1; - else _nb_calc *= 2; - action.initialize(); - m_time_action = time_calculate(action); - } - - // optimize - for (int i=1; i -// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef _PORTABLE_PERF_ANALYZER_HH -#define _PORTABLE_PERF_ANALYZER_HH - -#include "utilities.h" -#include "timers/portable_timer.hh" - -template -class Portable_Perf_Analyzer{ -public: - Portable_Perf_Analyzer( void ):_nb_calc(1),_nb_init(1),_chronos(){ - MESSAGE("Portable_Perf_Analyzer Ctor"); - }; - Portable_Perf_Analyzer( const Portable_Perf_Analyzer & ){ - INFOS("Copy Ctor not implemented"); - exit(0); - }; - ~Portable_Perf_Analyzer( void ){ - MESSAGE("Portable_Perf_Analyzer Dtor"); - }; - - - - inline double eval_mflops(int size) - { - - Action action(size); - -// double time_baseline = time_init(action); -// while (time_baseline < MIN_TIME_INIT) -// { -// _nb_init *= 2; -// time_baseline = time_init(action); -// } -// -// // optimize -// for (int i=1; i -#include -#include -#include - -class Portable_Timer -{ - public: - - Portable_Timer() - { - m_clkid = BtlConfig::Instance.realclock ? CLOCK_REALTIME : CLOCK_PROCESS_CPUTIME_ID; - } - - Portable_Timer(int clkid) : m_clkid(clkid) - {} - - void start() - { - timespec ts; - clock_gettime(m_clkid, &ts); - m_start_time = double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec); - - } - - void stop() - { - timespec ts; - clock_gettime(m_clkid, &ts); - m_stop_time = double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec); - - } - - double elapsed() - { - return user_time(); - } - - double user_time() - { - return m_stop_time - m_start_time; - } - - -private: - - int m_clkid; - double m_stop_time, m_start_time; - -}; // Portable_Timer - -#endif - -#endif // PORTABLE_TIMER_HPP diff --git a/eigen3/bench/btl/generic_bench/timers/x86_perf_analyzer.hh b/eigen3/bench/btl/generic_bench/timers/x86_perf_analyzer.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/timers/x86_perf_analyzer.hh +++ /dev/null @@ -1,108 +0,0 @@ -//===================================================== -// File : x86_perf_analyzer.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef _X86_PERF_ANALYSER_HH -#define _X86_PERF_ANALYSER_HH - -#include "x86_timer.hh" -#include "bench_parameter.hh" - -template -class X86_Perf_Analyzer{ -public: - X86_Perf_Analyzer( unsigned long long nb_sample=DEFAULT_NB_SAMPLE):_nb_sample(nb_sample),_chronos() - { - MESSAGE("X86_Perf_Analyzer Ctor"); - _chronos.find_frequency(); - }; - X86_Perf_Analyzer( const X86_Perf_Analyzer & ){ - INFOS("Copy Ctor not implemented"); - exit(0); - }; - ~X86_Perf_Analyzer( void ){ - MESSAGE("X86_Perf_Analyzer Dtor"); - }; - - - inline double eval_mflops(int size) - { - - ACTION action(size); - - int nb_loop=5; - double calculate_time=0.0; - double baseline_time=0.0; - - for (int j=0 ; j < nb_loop ; j++){ - - _chronos.clear(); - - for(int i=0 ; i < _nb_sample ; i++) - { - _chronos.start(); - action.initialize(); - action.calculate(); - _chronos.stop(); - _chronos.add_get_click(); - } - - calculate_time += double(_chronos.get_shortest_clicks())/_chronos.frequency(); - - if (j==0) action.check_result(); - - _chronos.clear(); - - for(int i=0 ; i < _nb_sample ; i++) - { - _chronos.start(); - action.initialize(); - _chronos.stop(); - _chronos.add_get_click(); - - } - - baseline_time+=double(_chronos.get_shortest_clicks())/_chronos.frequency(); - - } - - double corrected_time = (calculate_time-baseline_time)/double(nb_loop); - - -// INFOS("_nb_sample="<<_nb_sample); -// INFOS("baseline_time="< -// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef _X86_TIMER_HH -#define _X86_TIMER_HH - -#include -#include -#include -#include -//#include "system_time.h" -#define u32 unsigned int -#include -#include "utilities.h" -#include -#include -#include -#include - -// frequence de la becanne en Hz -//#define FREQUENCY 648000000 -//#define FREQUENCY 1400000000 -#define FREQUENCY 1695000000 - -using namespace std; - - -class X86_Timer { - -public : - - X86_Timer( void ):_frequency(FREQUENCY),_nb_sample(0) - { - MESSAGE("X86_Timer Default Ctor"); - } - - inline void start( void ){ - - rdtsc(_click_start.n32[0],_click_start.n32[1]); - - } - - - inline void stop( void ){ - - rdtsc(_click_stop.n32[0],_click_stop.n32[1]); - - } - - - inline double frequency( void ){ - return _frequency; - } - - double get_elapsed_time_in_second( void ){ - - return (_click_stop.n64-_click_start.n64)/double(FREQUENCY); - - - } - - unsigned long long get_click( void ){ - - return (_click_stop.n64-_click_start.n64); - - } - - inline void find_frequency( void ){ - - time_t initial, final; - int dummy=2; - - initial = time(0); - start(); - do { - dummy+=2; - } - while(time(0)==initial); - // On est au debut d'un cycle d'une seconde !!! - initial = time(0); - start(); - do { - dummy+=2; - } - while(time(0)==initial); - final=time(0); - stop(); - // INFOS("fine grained time : "<< get_elapsed_time_in_second()); - // INFOS("coarse grained time : "<< final-initial); - _frequency=_frequency*get_elapsed_time_in_second()/double(final-initial); - /// INFOS("CPU frequency : "<< _frequency); - - } - - void add_get_click( void ){ - - _nb_sample++; - _counted_clicks[get_click()]++; - fill_history_clicks(); - - } - - void dump_statistics(string filemane){ - - ofstream outfile (filemane.c_str(),ios::out) ; - - std::map::iterator itr; - for(itr=_counted_clicks.begin() ; itr!=_counted_clicks.end() ; itr++) - { - outfile << (*itr).first << " " << (*itr).second << endl ; - } - - outfile.close(); - - } - - void dump_history(string filemane){ - - ofstream outfile (filemane.c_str(),ios::out) ; - - - - for(int i=0 ; i<_history_mean_clicks.size() ; i++) - { - outfile << i << " " - << _history_mean_clicks[i] << " " - << _history_shortest_clicks[i] << " " - << _history_most_occured_clicks[i] << endl ; - } - - outfile.close(); - - } - - - - double get_mean_clicks( void ){ - - std::map::iterator itr; - - unsigned long long mean_clicks=0; - - for(itr=_counted_clicks.begin() ; itr!=_counted_clicks.end() ; itr++) - { - - mean_clicks+=(*itr).second*(*itr).first; - } - - return mean_clicks/double(_nb_sample); - - } - - double get_shortest_clicks( void ){ - - return double((*_counted_clicks.begin()).first); - - } - - void fill_history_clicks( void ){ - - _history_mean_clicks.push_back(get_mean_clicks()); - _history_shortest_clicks.push_back(get_shortest_clicks()); - _history_most_occured_clicks.push_back(get_most_occured_clicks()); - - } - - - double get_most_occured_clicks( void ){ - - unsigned long long moc=0; - unsigned long long max_occurence=0; - - std::map::iterator itr; - - for(itr=_counted_clicks.begin() ; itr!=_counted_clicks.end() ; itr++) - { - - if (max_occurence<=(*itr).second){ - max_occurence=(*itr).second; - moc=(*itr).first; - } - } - - return double(moc); - - } - - void clear( void ) - { - _counted_clicks.clear(); - - _history_mean_clicks.clear(); - _history_shortest_clicks.clear(); - _history_most_occured_clicks.clear(); - - _nb_sample=0; - } - - - -private : - - union - { - unsigned long int n32[2] ; - unsigned long long n64 ; - } _click_start; - - union - { - unsigned long int n32[2] ; - unsigned long long n64 ; - } _click_stop; - - double _frequency ; - - map _counted_clicks; - - vector _history_mean_clicks; - vector _history_shortest_clicks; - vector _history_most_occured_clicks; - - unsigned long long _nb_sample; - - - -}; - - -#endif diff --git a/eigen3/bench/btl/generic_bench/utils/size_lin_log.hh b/eigen3/bench/btl/generic_bench/utils/size_lin_log.hh deleted file mode 100644 --- a/eigen3/bench/btl/generic_bench/utils/size_lin_log.hh +++ /dev/null @@ -1,70 +0,0 @@ -//===================================================== -// File : size_lin_log.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, mar déc 3 18:59:37 CET 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef SIZE_LIN_LOG -#define SIZE_LIN_LOG - -#include "size_log.hh" - -template -void size_lin_log(const int nb_point, const int size_min, const int size_max, Vector & X) -{ - int ten=10; - int nine=9; - - X.resize(nb_point); - - if (nb_point>ten){ - - for (int i=0;i -void size_log(const int nb_point, const int size_min, const int size_max, Vector & X) -{ - X.resize(nb_point); - - float ls_min=log(float(size_min)); - float ls_max=log(float(size_max)); - - float ls=0.0; - - float delta_ls=(ls_max-ls_min)/(float(nb_point-1)); - - int size=0; - - for (int i=0;i -//# include ok for gcc3.01 -# include - -/* --- INFOS is always defined (without _DEBUG_): to be used for warnings, with release version --- */ - -# define HEREWEARE cout< -// Copyright (C) EDF R&D, lun sep 30 14:23:20 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef XY_FILE_HH -#define XY_FILE_HH -#include -#include -#include -#include -using namespace std; - -bool read_xy_file(const std::string & filename, std::vector & tab_sizes, - std::vector & tab_mflops, bool quiet = false) -{ - - std::ifstream input_file (filename.c_str(),std::ios::in); - - if (!input_file){ - if (!quiet) { - INFOS("!!! Error opening "<> size >> mflops ){ - nb_point++; - tab_sizes.push_back(size); - tab_mflops.push_back(mflops); - } - SCRUTE(nb_point); - - input_file.close(); - return true; -} - -// The Vector class must satisfy the following part of STL vector concept : -// resize() method -// [] operator for seting element -// the vector element must have the << operator define - -using namespace std; - -template -void dump_xy_file(const Vector_A & X, const Vector_B & Y, const std::string & filename){ - - ofstream outfile (filename.c_str(),ios::out) ; - int size=X.size(); - - for (int i=0;i BLASFUNC(cdotu) (int *, float *, int *, float *, int *); -std::complex BLASFUNC(cdotc) (int *, float *, int *, float *, int *); -std::complex BLASFUNC(zdotu) (int *, double *, int *, double *, int *); -std::complex BLASFUNC(zdotc) (int *, double *, int *, double *, int *); -double BLASFUNC(xdotu) (int *, double *, int *, double *, int *); -double BLASFUNC(xdotc) (int *, double *, int *, double *, int *); -#endif - -int BLASFUNC(cdotuw) (int *, float *, int *, float *, int *, float*); -int BLASFUNC(cdotcw) (int *, float *, int *, float *, int *, float*); -int BLASFUNC(zdotuw) (int *, double *, int *, double *, int *, double*); -int BLASFUNC(zdotcw) (int *, double *, int *, double *, int *, double*); - -int BLASFUNC(saxpy) (int *, float *, float *, int *, float *, int *); -int BLASFUNC(daxpy) (int *, double *, double *, int *, double *, int *); -int BLASFUNC(qaxpy) (int *, double *, double *, int *, double *, int *); -int BLASFUNC(caxpy) (int *, float *, float *, int *, float *, int *); -int BLASFUNC(zaxpy) (int *, double *, double *, int *, double *, int *); -int BLASFUNC(xaxpy) (int *, double *, double *, int *, double *, int *); -int BLASFUNC(caxpyc)(int *, float *, float *, int *, float *, int *); -int BLASFUNC(zaxpyc)(int *, double *, double *, int *, double *, int *); -int BLASFUNC(xaxpyc)(int *, double *, double *, int *, double *, int *); - -int BLASFUNC(scopy) (int *, float *, int *, float *, int *); -int BLASFUNC(dcopy) (int *, double *, int *, double *, int *); -int BLASFUNC(qcopy) (int *, double *, int *, double *, int *); -int BLASFUNC(ccopy) (int *, float *, int *, float *, int *); -int BLASFUNC(zcopy) (int *, double *, int *, double *, int *); -int BLASFUNC(xcopy) (int *, double *, int *, double *, int *); - -int BLASFUNC(sswap) (int *, float *, int *, float *, int *); -int BLASFUNC(dswap) (int *, double *, int *, double *, int *); -int BLASFUNC(qswap) (int *, double *, int *, double *, int *); -int BLASFUNC(cswap) (int *, float *, int *, float *, int *); -int BLASFUNC(zswap) (int *, double *, int *, double *, int *); -int BLASFUNC(xswap) (int *, double *, int *, double *, int *); - -float BLASFUNC(sasum) (int *, float *, int *); -float BLASFUNC(scasum)(int *, float *, int *); -double BLASFUNC(dasum) (int *, double *, int *); -double BLASFUNC(qasum) (int *, double *, int *); -double BLASFUNC(dzasum)(int *, double *, int *); -double BLASFUNC(qxasum)(int *, double *, int *); - -int BLASFUNC(isamax)(int *, float *, int *); -int BLASFUNC(idamax)(int *, double *, int *); -int BLASFUNC(iqamax)(int *, double *, int *); -int BLASFUNC(icamax)(int *, float *, int *); -int BLASFUNC(izamax)(int *, double *, int *); -int BLASFUNC(ixamax)(int *, double *, int *); - -int BLASFUNC(ismax) (int *, float *, int *); -int BLASFUNC(idmax) (int *, double *, int *); -int BLASFUNC(iqmax) (int *, double *, int *); -int BLASFUNC(icmax) (int *, float *, int *); -int BLASFUNC(izmax) (int *, double *, int *); -int BLASFUNC(ixmax) (int *, double *, int *); - -int BLASFUNC(isamin)(int *, float *, int *); -int BLASFUNC(idamin)(int *, double *, int *); -int BLASFUNC(iqamin)(int *, double *, int *); -int BLASFUNC(icamin)(int *, float *, int *); -int BLASFUNC(izamin)(int *, double *, int *); -int BLASFUNC(ixamin)(int *, double *, int *); - -int BLASFUNC(ismin)(int *, float *, int *); -int BLASFUNC(idmin)(int *, double *, int *); -int BLASFUNC(iqmin)(int *, double *, int *); -int BLASFUNC(icmin)(int *, float *, int *); -int BLASFUNC(izmin)(int *, double *, int *); -int BLASFUNC(ixmin)(int *, double *, int *); - -float BLASFUNC(samax) (int *, float *, int *); -double BLASFUNC(damax) (int *, double *, int *); -double BLASFUNC(qamax) (int *, double *, int *); -float BLASFUNC(scamax)(int *, float *, int *); -double BLASFUNC(dzamax)(int *, double *, int *); -double BLASFUNC(qxamax)(int *, double *, int *); - -float BLASFUNC(samin) (int *, float *, int *); -double BLASFUNC(damin) (int *, double *, int *); -double BLASFUNC(qamin) (int *, double *, int *); -float BLASFUNC(scamin)(int *, float *, int *); -double BLASFUNC(dzamin)(int *, double *, int *); -double BLASFUNC(qxamin)(int *, double *, int *); - -float BLASFUNC(smax) (int *, float *, int *); -double BLASFUNC(dmax) (int *, double *, int *); -double BLASFUNC(qmax) (int *, double *, int *); -float BLASFUNC(scmax) (int *, float *, int *); -double BLASFUNC(dzmax) (int *, double *, int *); -double BLASFUNC(qxmax) (int *, double *, int *); - -float BLASFUNC(smin) (int *, float *, int *); -double BLASFUNC(dmin) (int *, double *, int *); -double BLASFUNC(qmin) (int *, double *, int *); -float BLASFUNC(scmin) (int *, float *, int *); -double BLASFUNC(dzmin) (int *, double *, int *); -double BLASFUNC(qxmin) (int *, double *, int *); - -int BLASFUNC(sscal) (int *, float *, float *, int *); -int BLASFUNC(dscal) (int *, double *, double *, int *); -int BLASFUNC(qscal) (int *, double *, double *, int *); -int BLASFUNC(cscal) (int *, float *, float *, int *); -int BLASFUNC(zscal) (int *, double *, double *, int *); -int BLASFUNC(xscal) (int *, double *, double *, int *); -int BLASFUNC(csscal)(int *, float *, float *, int *); -int BLASFUNC(zdscal)(int *, double *, double *, int *); -int BLASFUNC(xqscal)(int *, double *, double *, int *); - -float BLASFUNC(snrm2) (int *, float *, int *); -float BLASFUNC(scnrm2)(int *, float *, int *); - -double BLASFUNC(dnrm2) (int *, double *, int *); -double BLASFUNC(qnrm2) (int *, double *, int *); -double BLASFUNC(dznrm2)(int *, double *, int *); -double BLASFUNC(qxnrm2)(int *, double *, int *); - -int BLASFUNC(srot) (int *, float *, int *, float *, int *, float *, float *); -int BLASFUNC(drot) (int *, double *, int *, double *, int *, double *, double *); -int BLASFUNC(qrot) (int *, double *, int *, double *, int *, double *, double *); -int BLASFUNC(csrot) (int *, float *, int *, float *, int *, float *, float *); -int BLASFUNC(zdrot) (int *, double *, int *, double *, int *, double *, double *); -int BLASFUNC(xqrot) (int *, double *, int *, double *, int *, double *, double *); - -int BLASFUNC(srotg) (float *, float *, float *, float *); -int BLASFUNC(drotg) (double *, double *, double *, double *); -int BLASFUNC(qrotg) (double *, double *, double *, double *); -int BLASFUNC(crotg) (float *, float *, float *, float *); -int BLASFUNC(zrotg) (double *, double *, double *, double *); -int BLASFUNC(xrotg) (double *, double *, double *, double *); - -int BLASFUNC(srotmg)(float *, float *, float *, float *, float *); -int BLASFUNC(drotmg)(double *, double *, double *, double *, double *); - -int BLASFUNC(srotm) (int *, float *, int *, float *, int *, float *); -int BLASFUNC(drotm) (int *, double *, int *, double *, int *, double *); -int BLASFUNC(qrotm) (int *, double *, int *, double *, int *, double *); - -/* Level 2 routines */ - -int BLASFUNC(sger)(int *, int *, float *, float *, int *, - float *, int *, float *, int *); -int BLASFUNC(dger)(int *, int *, double *, double *, int *, - double *, int *, double *, int *); -int BLASFUNC(qger)(int *, int *, double *, double *, int *, - double *, int *, double *, int *); -int BLASFUNC(cgeru)(int *, int *, float *, float *, int *, - float *, int *, float *, int *); -int BLASFUNC(cgerc)(int *, int *, float *, float *, int *, - float *, int *, float *, int *); -int BLASFUNC(zgeru)(int *, int *, double *, double *, int *, - double *, int *, double *, int *); -int BLASFUNC(zgerc)(int *, int *, double *, double *, int *, - double *, int *, double *, int *); -int BLASFUNC(xgeru)(int *, int *, double *, double *, int *, - double *, int *, double *, int *); -int BLASFUNC(xgerc)(int *, int *, double *, double *, int *, - double *, int *, double *, int *); - -int BLASFUNC(sgemv)(char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(dgemv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(qgemv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(cgemv)(char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zgemv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xgemv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(strsv) (char *, char *, char *, int *, float *, int *, - float *, int *); -int BLASFUNC(dtrsv) (char *, char *, char *, int *, double *, int *, - double *, int *); -int BLASFUNC(qtrsv) (char *, char *, char *, int *, double *, int *, - double *, int *); -int BLASFUNC(ctrsv) (char *, char *, char *, int *, float *, int *, - float *, int *); -int BLASFUNC(ztrsv) (char *, char *, char *, int *, double *, int *, - double *, int *); -int BLASFUNC(xtrsv) (char *, char *, char *, int *, double *, int *, - double *, int *); - -int BLASFUNC(stpsv) (char *, char *, char *, int *, float *, float *, int *); -int BLASFUNC(dtpsv) (char *, char *, char *, int *, double *, double *, int *); -int BLASFUNC(qtpsv) (char *, char *, char *, int *, double *, double *, int *); -int BLASFUNC(ctpsv) (char *, char *, char *, int *, float *, float *, int *); -int BLASFUNC(ztpsv) (char *, char *, char *, int *, double *, double *, int *); -int BLASFUNC(xtpsv) (char *, char *, char *, int *, double *, double *, int *); - -int BLASFUNC(strmv) (char *, char *, char *, int *, float *, int *, - float *, int *); -int BLASFUNC(dtrmv) (char *, char *, char *, int *, double *, int *, - double *, int *); -int BLASFUNC(qtrmv) (char *, char *, char *, int *, double *, int *, - double *, int *); -int BLASFUNC(ctrmv) (char *, char *, char *, int *, float *, int *, - float *, int *); -int BLASFUNC(ztrmv) (char *, char *, char *, int *, double *, int *, - double *, int *); -int BLASFUNC(xtrmv) (char *, char *, char *, int *, double *, int *, - double *, int *); - -int BLASFUNC(stpmv) (char *, char *, char *, int *, float *, float *, int *); -int BLASFUNC(dtpmv) (char *, char *, char *, int *, double *, double *, int *); -int BLASFUNC(qtpmv) (char *, char *, char *, int *, double *, double *, int *); -int BLASFUNC(ctpmv) (char *, char *, char *, int *, float *, float *, int *); -int BLASFUNC(ztpmv) (char *, char *, char *, int *, double *, double *, int *); -int BLASFUNC(xtpmv) (char *, char *, char *, int *, double *, double *, int *); - -int BLASFUNC(stbmv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); -int BLASFUNC(dtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); -int BLASFUNC(qtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); -int BLASFUNC(ctbmv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); -int BLASFUNC(ztbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); -int BLASFUNC(xtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); - -int BLASFUNC(stbsv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); -int BLASFUNC(dtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); -int BLASFUNC(qtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); -int BLASFUNC(ctbsv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); -int BLASFUNC(ztbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); -int BLASFUNC(xtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); - -int BLASFUNC(ssymv) (char *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(dsymv) (char *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(qsymv) (char *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(csymv) (char *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zsymv) (char *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xsymv) (char *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(sspmv) (char *, int *, float *, float *, - float *, int *, float *, float *, int *); -int BLASFUNC(dspmv) (char *, int *, double *, double *, - double *, int *, double *, double *, int *); -int BLASFUNC(qspmv) (char *, int *, double *, double *, - double *, int *, double *, double *, int *); -int BLASFUNC(cspmv) (char *, int *, float *, float *, - float *, int *, float *, float *, int *); -int BLASFUNC(zspmv) (char *, int *, double *, double *, - double *, int *, double *, double *, int *); -int BLASFUNC(xspmv) (char *, int *, double *, double *, - double *, int *, double *, double *, int *); - -int BLASFUNC(ssyr) (char *, int *, float *, float *, int *, - float *, int *); -int BLASFUNC(dsyr) (char *, int *, double *, double *, int *, - double *, int *); -int BLASFUNC(qsyr) (char *, int *, double *, double *, int *, - double *, int *); -int BLASFUNC(csyr) (char *, int *, float *, float *, int *, - float *, int *); -int BLASFUNC(zsyr) (char *, int *, double *, double *, int *, - double *, int *); -int BLASFUNC(xsyr) (char *, int *, double *, double *, int *, - double *, int *); - -int BLASFUNC(ssyr2) (char *, int *, float *, - float *, int *, float *, int *, float *, int *); -int BLASFUNC(dsyr2) (char *, int *, double *, - double *, int *, double *, int *, double *, int *); -int BLASFUNC(qsyr2) (char *, int *, double *, - double *, int *, double *, int *, double *, int *); -int BLASFUNC(csyr2) (char *, int *, float *, - float *, int *, float *, int *, float *, int *); -int BLASFUNC(zsyr2) (char *, int *, double *, - double *, int *, double *, int *, double *, int *); -int BLASFUNC(xsyr2) (char *, int *, double *, - double *, int *, double *, int *, double *, int *); - -int BLASFUNC(sspr) (char *, int *, float *, float *, int *, - float *); -int BLASFUNC(dspr) (char *, int *, double *, double *, int *, - double *); -int BLASFUNC(qspr) (char *, int *, double *, double *, int *, - double *); -int BLASFUNC(cspr) (char *, int *, float *, float *, int *, - float *); -int BLASFUNC(zspr) (char *, int *, double *, double *, int *, - double *); -int BLASFUNC(xspr) (char *, int *, double *, double *, int *, - double *); - -int BLASFUNC(sspr2) (char *, int *, float *, - float *, int *, float *, int *, float *); -int BLASFUNC(dspr2) (char *, int *, double *, - double *, int *, double *, int *, double *); -int BLASFUNC(qspr2) (char *, int *, double *, - double *, int *, double *, int *, double *); -int BLASFUNC(cspr2) (char *, int *, float *, - float *, int *, float *, int *, float *); -int BLASFUNC(zspr2) (char *, int *, double *, - double *, int *, double *, int *, double *); -int BLASFUNC(xspr2) (char *, int *, double *, - double *, int *, double *, int *, double *); - -int BLASFUNC(cher) (char *, int *, float *, float *, int *, - float *, int *); -int BLASFUNC(zher) (char *, int *, double *, double *, int *, - double *, int *); -int BLASFUNC(xher) (char *, int *, double *, double *, int *, - double *, int *); - -int BLASFUNC(chpr) (char *, int *, float *, float *, int *, float *); -int BLASFUNC(zhpr) (char *, int *, double *, double *, int *, double *); -int BLASFUNC(xhpr) (char *, int *, double *, double *, int *, double *); - -int BLASFUNC(cher2) (char *, int *, float *, - float *, int *, float *, int *, float *, int *); -int BLASFUNC(zher2) (char *, int *, double *, - double *, int *, double *, int *, double *, int *); -int BLASFUNC(xher2) (char *, int *, double *, - double *, int *, double *, int *, double *, int *); - -int BLASFUNC(chpr2) (char *, int *, float *, - float *, int *, float *, int *, float *); -int BLASFUNC(zhpr2) (char *, int *, double *, - double *, int *, double *, int *, double *); -int BLASFUNC(xhpr2) (char *, int *, double *, - double *, int *, double *, int *, double *); - -int BLASFUNC(chemv) (char *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zhemv) (char *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xhemv) (char *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(chpmv) (char *, int *, float *, float *, - float *, int *, float *, float *, int *); -int BLASFUNC(zhpmv) (char *, int *, double *, double *, - double *, int *, double *, double *, int *); -int BLASFUNC(xhpmv) (char *, int *, double *, double *, - double *, int *, double *, double *, int *); - -int BLASFUNC(snorm)(char *, int *, int *, float *, int *); -int BLASFUNC(dnorm)(char *, int *, int *, double *, int *); -int BLASFUNC(cnorm)(char *, int *, int *, float *, int *); -int BLASFUNC(znorm)(char *, int *, int *, double *, int *); - -int BLASFUNC(sgbmv)(char *, int *, int *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(dgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(qgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(cgbmv)(char *, int *, int *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(ssbmv)(char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(dsbmv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(qsbmv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(csbmv)(char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zsbmv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xsbmv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(chbmv)(char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zhbmv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xhbmv)(char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -/* Level 3 routines */ - -int BLASFUNC(sgemm)(char *, char *, int *, int *, int *, float *, - float *, int *, float *, int *, float *, float *, int *); -int BLASFUNC(dgemm)(char *, char *, int *, int *, int *, double *, - double *, int *, double *, int *, double *, double *, int *); -int BLASFUNC(qgemm)(char *, char *, int *, int *, int *, double *, - double *, int *, double *, int *, double *, double *, int *); -int BLASFUNC(cgemm)(char *, char *, int *, int *, int *, float *, - float *, int *, float *, int *, float *, float *, int *); -int BLASFUNC(zgemm)(char *, char *, int *, int *, int *, double *, - double *, int *, double *, int *, double *, double *, int *); -int BLASFUNC(xgemm)(char *, char *, int *, int *, int *, double *, - double *, int *, double *, int *, double *, double *, int *); - -int BLASFUNC(cgemm3m)(char *, char *, int *, int *, int *, float *, - float *, int *, float *, int *, float *, float *, int *); -int BLASFUNC(zgemm3m)(char *, char *, int *, int *, int *, double *, - double *, int *, double *, int *, double *, double *, int *); -int BLASFUNC(xgemm3m)(char *, char *, int *, int *, int *, double *, - double *, int *, double *, int *, double *, double *, int *); - -int BLASFUNC(sge2mm)(char *, char *, char *, int *, int *, - float *, float *, int *, float *, int *, - float *, float *, int *); -int BLASFUNC(dge2mm)(char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *, - double *, double *, int *); -int BLASFUNC(cge2mm)(char *, char *, char *, int *, int *, - float *, float *, int *, float *, int *, - float *, float *, int *); -int BLASFUNC(zge2mm)(char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *, - double *, double *, int *); - -int BLASFUNC(strsm)(char *, char *, char *, char *, int *, int *, - float *, float *, int *, float *, int *); -int BLASFUNC(dtrsm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); -int BLASFUNC(qtrsm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); -int BLASFUNC(ctrsm)(char *, char *, char *, char *, int *, int *, - float *, float *, int *, float *, int *); -int BLASFUNC(ztrsm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); -int BLASFUNC(xtrsm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); - -int BLASFUNC(strmm)(char *, char *, char *, char *, int *, int *, - float *, float *, int *, float *, int *); -int BLASFUNC(dtrmm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); -int BLASFUNC(qtrmm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); -int BLASFUNC(ctrmm)(char *, char *, char *, char *, int *, int *, - float *, float *, int *, float *, int *); -int BLASFUNC(ztrmm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); -int BLASFUNC(xtrmm)(char *, char *, char *, char *, int *, int *, - double *, double *, int *, double *, int *); - -int BLASFUNC(ssymm)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(dsymm)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(qsymm)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(csymm)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zsymm)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xsymm)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(csymm3m)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zsymm3m)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xsymm3m)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(ssyrk)(char *, char *, int *, int *, float *, float *, int *, - float *, float *, int *); -int BLASFUNC(dsyrk)(char *, char *, int *, int *, double *, double *, int *, - double *, double *, int *); -int BLASFUNC(qsyrk)(char *, char *, int *, int *, double *, double *, int *, - double *, double *, int *); -int BLASFUNC(csyrk)(char *, char *, int *, int *, float *, float *, int *, - float *, float *, int *); -int BLASFUNC(zsyrk)(char *, char *, int *, int *, double *, double *, int *, - double *, double *, int *); -int BLASFUNC(xsyrk)(char *, char *, int *, int *, double *, double *, int *, - double *, double *, int *); - -int BLASFUNC(ssyr2k)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(dsyr2k)(char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); -int BLASFUNC(qsyr2k)(char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); -int BLASFUNC(csyr2k)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zsyr2k)(char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); -int BLASFUNC(xsyr2k)(char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); - -int BLASFUNC(chemm)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zhemm)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xhemm)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(chemm3m)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zhemm3m)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); -int BLASFUNC(xhemm3m)(char *, char *, int *, int *, double *, double *, int *, - double *, int *, double *, double *, int *); - -int BLASFUNC(cherk)(char *, char *, int *, int *, float *, float *, int *, - float *, float *, int *); -int BLASFUNC(zherk)(char *, char *, int *, int *, double *, double *, int *, - double *, double *, int *); -int BLASFUNC(xherk)(char *, char *, int *, int *, double *, double *, int *, - double *, double *, int *); - -int BLASFUNC(cher2k)(char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zher2k)(char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); -int BLASFUNC(xher2k)(char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); -int BLASFUNC(cher2m)(char *, char *, char *, int *, int *, float *, float *, int *, - float *, int *, float *, float *, int *); -int BLASFUNC(zher2m)(char *, char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); -int BLASFUNC(xher2m)(char *, char *, char *, int *, int *, double *, double *, int *, - double*, int *, double *, double *, int *); - -int BLASFUNC(sgemt)(char *, int *, int *, float *, float *, int *, - float *, int *); -int BLASFUNC(dgemt)(char *, int *, int *, double *, double *, int *, - double *, int *); -int BLASFUNC(cgemt)(char *, int *, int *, float *, float *, int *, - float *, int *); -int BLASFUNC(zgemt)(char *, int *, int *, double *, double *, int *, - double *, int *); - -int BLASFUNC(sgema)(char *, char *, int *, int *, float *, - float *, int *, float *, float *, int *, float *, int *); -int BLASFUNC(dgema)(char *, char *, int *, int *, double *, - double *, int *, double*, double *, int *, double*, int *); -int BLASFUNC(cgema)(char *, char *, int *, int *, float *, - float *, int *, float *, float *, int *, float *, int *); -int BLASFUNC(zgema)(char *, char *, int *, int *, double *, - double *, int *, double*, double *, int *, double*, int *); - -int BLASFUNC(sgems)(char *, char *, int *, int *, float *, - float *, int *, float *, float *, int *, float *, int *); -int BLASFUNC(dgems)(char *, char *, int *, int *, double *, - double *, int *, double*, double *, int *, double*, int *); -int BLASFUNC(cgems)(char *, char *, int *, int *, float *, - float *, int *, float *, float *, int *, float *, int *); -int BLASFUNC(zgems)(char *, char *, int *, int *, double *, - double *, int *, double*, double *, int *, double*, int *); - -int BLASFUNC(sgetf2)(int *, int *, float *, int *, int *, int *); -int BLASFUNC(dgetf2)(int *, int *, double *, int *, int *, int *); -int BLASFUNC(qgetf2)(int *, int *, double *, int *, int *, int *); -int BLASFUNC(cgetf2)(int *, int *, float *, int *, int *, int *); -int BLASFUNC(zgetf2)(int *, int *, double *, int *, int *, int *); -int BLASFUNC(xgetf2)(int *, int *, double *, int *, int *, int *); - -int BLASFUNC(sgetrf)(int *, int *, float *, int *, int *, int *); -int BLASFUNC(dgetrf)(int *, int *, double *, int *, int *, int *); -int BLASFUNC(qgetrf)(int *, int *, double *, int *, int *, int *); -int BLASFUNC(cgetrf)(int *, int *, float *, int *, int *, int *); -int BLASFUNC(zgetrf)(int *, int *, double *, int *, int *, int *); -int BLASFUNC(xgetrf)(int *, int *, double *, int *, int *, int *); - -int BLASFUNC(slaswp)(int *, float *, int *, int *, int *, int *, int *); -int BLASFUNC(dlaswp)(int *, double *, int *, int *, int *, int *, int *); -int BLASFUNC(qlaswp)(int *, double *, int *, int *, int *, int *, int *); -int BLASFUNC(claswp)(int *, float *, int *, int *, int *, int *, int *); -int BLASFUNC(zlaswp)(int *, double *, int *, int *, int *, int *, int *); -int BLASFUNC(xlaswp)(int *, double *, int *, int *, int *, int *, int *); - -int BLASFUNC(sgetrs)(char *, int *, int *, float *, int *, int *, float *, int *, int *); -int BLASFUNC(dgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); -int BLASFUNC(qgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); -int BLASFUNC(cgetrs)(char *, int *, int *, float *, int *, int *, float *, int *, int *); -int BLASFUNC(zgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); -int BLASFUNC(xgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); - -int BLASFUNC(sgesv)(int *, int *, float *, int *, int *, float *, int *, int *); -int BLASFUNC(dgesv)(int *, int *, double *, int *, int *, double*, int *, int *); -int BLASFUNC(qgesv)(int *, int *, double *, int *, int *, double*, int *, int *); -int BLASFUNC(cgesv)(int *, int *, float *, int *, int *, float *, int *, int *); -int BLASFUNC(zgesv)(int *, int *, double *, int *, int *, double*, int *, int *); -int BLASFUNC(xgesv)(int *, int *, double *, int *, int *, double*, int *, int *); - -int BLASFUNC(spotf2)(char *, int *, float *, int *, int *); -int BLASFUNC(dpotf2)(char *, int *, double *, int *, int *); -int BLASFUNC(qpotf2)(char *, int *, double *, int *, int *); -int BLASFUNC(cpotf2)(char *, int *, float *, int *, int *); -int BLASFUNC(zpotf2)(char *, int *, double *, int *, int *); -int BLASFUNC(xpotf2)(char *, int *, double *, int *, int *); - -int BLASFUNC(spotrf)(char *, int *, float *, int *, int *); -int BLASFUNC(dpotrf)(char *, int *, double *, int *, int *); -int BLASFUNC(qpotrf)(char *, int *, double *, int *, int *); -int BLASFUNC(cpotrf)(char *, int *, float *, int *, int *); -int BLASFUNC(zpotrf)(char *, int *, double *, int *, int *); -int BLASFUNC(xpotrf)(char *, int *, double *, int *, int *); - -int BLASFUNC(slauu2)(char *, int *, float *, int *, int *); -int BLASFUNC(dlauu2)(char *, int *, double *, int *, int *); -int BLASFUNC(qlauu2)(char *, int *, double *, int *, int *); -int BLASFUNC(clauu2)(char *, int *, float *, int *, int *); -int BLASFUNC(zlauu2)(char *, int *, double *, int *, int *); -int BLASFUNC(xlauu2)(char *, int *, double *, int *, int *); - -int BLASFUNC(slauum)(char *, int *, float *, int *, int *); -int BLASFUNC(dlauum)(char *, int *, double *, int *, int *); -int BLASFUNC(qlauum)(char *, int *, double *, int *, int *); -int BLASFUNC(clauum)(char *, int *, float *, int *, int *); -int BLASFUNC(zlauum)(char *, int *, double *, int *, int *); -int BLASFUNC(xlauum)(char *, int *, double *, int *, int *); - -int BLASFUNC(strti2)(char *, char *, int *, float *, int *, int *); -int BLASFUNC(dtrti2)(char *, char *, int *, double *, int *, int *); -int BLASFUNC(qtrti2)(char *, char *, int *, double *, int *, int *); -int BLASFUNC(ctrti2)(char *, char *, int *, float *, int *, int *); -int BLASFUNC(ztrti2)(char *, char *, int *, double *, int *, int *); -int BLASFUNC(xtrti2)(char *, char *, int *, double *, int *, int *); - -int BLASFUNC(strtri)(char *, char *, int *, float *, int *, int *); -int BLASFUNC(dtrtri)(char *, char *, int *, double *, int *, int *); -int BLASFUNC(qtrtri)(char *, char *, int *, double *, int *, int *); -int BLASFUNC(ctrtri)(char *, char *, int *, float *, int *, int *); -int BLASFUNC(ztrtri)(char *, char *, int *, double *, int *, int *); -int BLASFUNC(xtrtri)(char *, char *, int *, double *, int *, int *); - -int BLASFUNC(spotri)(char *, int *, float *, int *, int *); -int BLASFUNC(dpotri)(char *, int *, double *, int *, int *); -int BLASFUNC(qpotri)(char *, int *, double *, int *, int *); -int BLASFUNC(cpotri)(char *, int *, float *, int *, int *); -int BLASFUNC(zpotri)(char *, int *, double *, int *, int *); -int BLASFUNC(xpotri)(char *, int *, double *, int *, int *); - -#endif diff --git a/eigen3/bench/btl/libs/BLAS/blas_interface.hh b/eigen3/bench/btl/libs/BLAS/blas_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/BLAS/blas_interface.hh +++ /dev/null @@ -1,83 +0,0 @@ -//===================================================== -// File : blas_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:28 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef blas_PRODUIT_MATRICE_VECTEUR_HH -#define blas_PRODUIT_MATRICE_VECTEUR_HH - -#include -#include -extern "C" -{ -#include "blas.h" - - // Cholesky Factorization -// void spotrf_(const char* uplo, const int* n, float *a, const int* ld, int* info); -// void dpotrf_(const char* uplo, const int* n, double *a, const int* ld, int* info); - void ssytrd_(char *uplo, const int *n, float *a, const int *lda, float *d, float *e, float *tau, float *work, int *lwork, int *info ); - void dsytrd_(char *uplo, const int *n, double *a, const int *lda, double *d, double *e, double *tau, double *work, int *lwork, int *info ); - void sgehrd_( const int *n, int *ilo, int *ihi, float *a, const int *lda, float *tau, float *work, int *lwork, int *info ); - void dgehrd_( const int *n, int *ilo, int *ihi, double *a, const int *lda, double *tau, double *work, int *lwork, int *info ); - - // LU row pivoting -// void dgetrf_( int *m, int *n, double *a, int *lda, int *ipiv, int *info ); -// void sgetrf_(const int* m, const int* n, float *a, const int* ld, int* ipivot, int* info); - // LU full pivoting - void sgetc2_(const int* n, float *a, const int *lda, int *ipiv, int *jpiv, int*info ); - void dgetc2_(const int* n, double *a, const int *lda, int *ipiv, int *jpiv, int*info ); -#ifdef HAS_LAPACK -#endif -} - -#define MAKE_STRING2(S) #S -#define MAKE_STRING(S) MAKE_STRING2(S) - -#define CAT2(A,B) A##B -#define CAT(A,B) CAT2(A,B) - - -template class blas_interface; - - -static char notrans = 'N'; -static char trans = 'T'; -static char nonunit = 'N'; -static char lower = 'L'; -static char right = 'R'; -static char left = 'L'; -static int intone = 1; - - - -#define SCALAR float -#define SCALAR_PREFIX s -#include "blas_interface_impl.hh" -#undef SCALAR -#undef SCALAR_PREFIX - - -#define SCALAR double -#define SCALAR_PREFIX d -#include "blas_interface_impl.hh" -#undef SCALAR -#undef SCALAR_PREFIX - -#endif - - - diff --git a/eigen3/bench/btl/libs/BLAS/blas_interface_impl.hh b/eigen3/bench/btl/libs/BLAS/blas_interface_impl.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/BLAS/blas_interface_impl.hh +++ /dev/null @@ -1,151 +0,0 @@ - -#define BLAS_FUNC(NAME) CAT(CAT(SCALAR_PREFIX,NAME),_) - -template<> class blas_interface : public c_interface_base -{ - -public : - - static SCALAR fone; - static SCALAR fzero; - - static inline std::string name() - { - return MAKE_STRING(CBLASNAME); - } - - static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ - BLAS_FUNC(gemv)(¬rans,&N,&N,&fone,A,&N,B,&intone,&fzero,X,&intone); - } - - static inline void symv(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ - BLAS_FUNC(symv)(&lower, &N,&fone,A,&N,B,&intone,&fzero,X,&intone); - } - - static inline void syr2(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ - BLAS_FUNC(syr2)(&lower,&N,&fone,B,&intone,X,&intone,A,&N); - } - - static inline void ger(gene_matrix & A, gene_vector & X, gene_vector & Y, int N){ - BLAS_FUNC(ger)(&N,&N,&fone,X,&intone,Y,&intone,A,&N); - } - - static inline void rot(gene_vector & A, gene_vector & B, SCALAR c, SCALAR s, int N){ - BLAS_FUNC(rot)(&N,A,&intone,B,&intone,&c,&s); - } - - static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ - BLAS_FUNC(gemv)(&trans,&N,&N,&fone,A,&N,B,&intone,&fzero,X,&intone); - } - - static inline void matrix_matrix_product(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ - BLAS_FUNC(gemm)(¬rans,¬rans,&N,&N,&N,&fone,A,&N,B,&N,&fzero,X,&N); - } - - static inline void transposed_matrix_matrix_product(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ - BLAS_FUNC(gemm)(¬rans,¬rans,&N,&N,&N,&fone,A,&N,B,&N,&fzero,X,&N); - } - -// static inline void ata_product(gene_matrix & A, gene_matrix & X, int N){ -// ssyrk_(&lower,&trans,&N,&N,&fone,A,&N,&fzero,X,&N); -// } - - static inline void aat_product(gene_matrix & A, gene_matrix & X, int N){ - BLAS_FUNC(syrk)(&lower,¬rans,&N,&N,&fone,A,&N,&fzero,X,&N); - } - - static inline void axpy(SCALAR coef, const gene_vector & X, gene_vector & Y, int N){ - BLAS_FUNC(axpy)(&N,&coef,X,&intone,Y,&intone); - } - - static inline void axpby(SCALAR a, const gene_vector & X, SCALAR b, gene_vector & Y, int N){ - BLAS_FUNC(scal)(&N,&b,Y,&intone); - BLAS_FUNC(axpy)(&N,&a,X,&intone,Y,&intone); - } - - static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){ - int N2 = N*N; - BLAS_FUNC(copy)(&N2, X, &intone, C, &intone); - char uplo = 'L'; - int info = 0; - BLAS_FUNC(potrf)(&uplo, &N, C, &N, &info); - if(info!=0) std::cerr << "potrf_ error " << info << "\n"; - } - - static inline void partial_lu_decomp(const gene_matrix & X, gene_matrix & C, int N){ - int N2 = N*N; - BLAS_FUNC(copy)(&N2, X, &intone, C, &intone); - char uplo = 'L'; - int info = 0; - int * ipiv = (int*)alloca(sizeof(int)*N); - BLAS_FUNC(getrf)(&N, &N, C, &N, ipiv, &info); - if(info!=0) std::cerr << "getrf_ error " << info << "\n"; - } - - static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector & X, int N){ - BLAS_FUNC(copy)(&N, B, &intone, X, &intone); - BLAS_FUNC(trsv)(&lower, ¬rans, &nonunit, &N, L, &N, X, &intone); - } - - static inline void trisolve_lower_matrix(const gene_matrix & L, const gene_matrix& B, gene_matrix & X, int N){ - BLAS_FUNC(copy)(&N, B, &intone, X, &intone); - BLAS_FUNC(trsm)(&right, &lower, ¬rans, &nonunit, &N, &N, &fone, L, &N, X, &N); - } - - static inline void trmm(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ - BLAS_FUNC(trmm)(&left, &lower, ¬rans,&nonunit, &N,&N,&fone,A,&N,B,&N); - } - - #ifdef HAS_LAPACK - - static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, int N){ - int N2 = N*N; - BLAS_FUNC(copy)(&N2, X, &intone, C, &intone); - char uplo = 'L'; - int info = 0; - int * ipiv = (int*)alloca(sizeof(int)*N); - int * jpiv = (int*)alloca(sizeof(int)*N); - BLAS_FUNC(getc2)(&N, C, &N, ipiv, jpiv, &info); - } - - - - static inline void hessenberg(const gene_matrix & X, gene_matrix & C, int N){ - { - int N2 = N*N; - int inc = 1; - BLAS_FUNC(copy)(&N2, X, &inc, C, &inc); - } - int info = 0; - int ilo = 1; - int ihi = N; - int bsize = 64; - int worksize = N*bsize; - SCALAR* d = new SCALAR[N+worksize]; - BLAS_FUNC(gehrd)(&N, &ilo, &ihi, C, &N, d, d+N, &worksize, &info); - delete[] d; - } - - static inline void tridiagonalization(const gene_matrix & X, gene_matrix & C, int N){ - { - int N2 = N*N; - int inc = 1; - BLAS_FUNC(copy)(&N2, X, &inc, C, &inc); - } - char uplo = 'U'; - int info = 0; - int ilo = 1; - int ihi = N; - int bsize = 64; - int worksize = N*bsize; - SCALAR* d = new SCALAR[3*N+worksize]; - BLAS_FUNC(sytrd)(&uplo, &N, C, &N, d, d+N, d+2*N, d+3*N, &worksize, &info); - delete[] d; - } - - #endif // HAS_LAPACK - -}; - -SCALAR blas_interface::fone = SCALAR(1); -SCALAR blas_interface::fzero = SCALAR(0); diff --git a/eigen3/bench/btl/libs/BLAS/c_interface_base.h b/eigen3/bench/btl/libs/BLAS/c_interface_base.h deleted file mode 100644 --- a/eigen3/bench/btl/libs/BLAS/c_interface_base.h +++ /dev/null @@ -1,73 +0,0 @@ - -#ifndef BTL_C_INTERFACE_BASE_H -#define BTL_C_INTERFACE_BASE_H - -#include "utilities.h" -#include - -template class c_interface_base -{ - -public: - - typedef real real_type; - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef real* gene_matrix; - typedef real* gene_vector; - - static void free_matrix(gene_matrix & A, int N){ - delete A; - } - - static void free_vector(gene_vector & B){ - delete B; - } - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - int N = A_stl.size(); - A = new real[N*N]; - for (int j=0;j -// Copyright (C) EDF R&D, lun sep 30 14:23:28 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "blas_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -#include "action_cholesky.hh" -#include "action_lu_decomp.hh" -#include "action_partial_lu.hh" -#include "action_trisolve_matrix.hh" - -#ifdef HAS_LAPACK -#include "action_hessenberg.hh" -#endif - -BTL_MAIN; - -int main() -{ - - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - #ifdef HAS_LAPACK - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - #endif - - //bench > >(MIN_LU,MAX_LU,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/STL/CMakeLists.txt b/eigen3/bench/btl/libs/STL/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/libs/STL/CMakeLists.txt +++ /dev/null @@ -1,2 +0,0 @@ - -btl_add_bench(btl_STL main.cpp OFF) diff --git a/eigen3/bench/btl/libs/STL/STL_interface.hh b/eigen3/bench/btl/libs/STL/STL_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/STL/STL_interface.hh +++ /dev/null @@ -1,244 +0,0 @@ -//===================================================== -// File : STL_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:24 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef STL_INTERFACE_HH -#define STL_INTERFACE_HH -#include -#include -#include "utilities.h" - -using namespace std; - -template -class STL_interface{ - -public : - - typedef real real_type ; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef stl_matrix gene_matrix; - - typedef stl_vector gene_vector; - - static inline std::string name( void ) - { - return "STL"; - } - - static void free_matrix(gene_matrix & A, int N){} - - static void free_vector(gene_vector & B){} - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - A = A_stl; - } - - static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){ - B = B_stl; - } - - static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){ - B_stl = B ; - } - - - static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){ - A_stl = A ; - } - - static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){ - for (int i=0;i=j) - { - for (int k=0;k > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/blitz/CMakeLists.txt b/eigen3/bench/btl/libs/blitz/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/libs/blitz/CMakeLists.txt +++ /dev/null @@ -1,17 +0,0 @@ - -find_package(Blitz) - -if (BLITZ_FOUND) - include_directories(${BLITZ_INCLUDES}) - - btl_add_bench(btl_blitz btl_blitz.cpp) - if (BUILD_btl_blitz) - target_link_libraries(btl_blitz ${BLITZ_LIBRARIES}) - endif (BUILD_btl_blitz) - - btl_add_bench(btl_tiny_blitz btl_tiny_blitz.cpp OFF) - if (BUILD_btl_tiny_blitz) - target_link_libraries(btl_tiny_blitz ${BLITZ_LIBRARIES}) - endif (BUILD_btl_tiny_blitz) - -endif (BLITZ_FOUND) diff --git a/eigen3/bench/btl/libs/blitz/blitz_LU_solve_interface.hh b/eigen3/bench/btl/libs/blitz/blitz_LU_solve_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/blitz/blitz_LU_solve_interface.hh +++ /dev/null @@ -1,192 +0,0 @@ -//===================================================== -// File : blitz_LU_solve_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:31 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BLITZ_LU_SOLVE_INTERFACE_HH -#define BLITZ_LU_SOLVE_INTERFACE_HH - -#include "blitz/array.h" -#include - -BZ_USING_NAMESPACE(blitz) - -template -class blitz_LU_solve_interface : public blitz_interface -{ - -public : - - typedef typename blitz_interface::gene_matrix gene_matrix; - typedef typename blitz_interface::gene_vector gene_vector; - - typedef blitz::Array Pivot_Vector; - - inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N) - { - - pivot.resize(N); - - } - - inline static void free_Pivot_Vector(Pivot_Vector & pivot) - { - - return; - - } - - - static inline real matrix_vector_product_sliced(const gene_matrix & A, gene_vector B, int row, int col_start, int col_end) - { - - real somme=0.; - - for (int j=col_start ; j=big ) big = abs( LU( i, j ) ) ; - } - if( big==0. ) { - INFOS( "blitz_LU_factor::Singular matrix" ) ; - exit( 0 ) ; - } - ImplicitScaling( i ) = 1./big ; - } - // Loop over columns of Crout's method : - for( int j=0; j=big ) { - dum = ImplicitScaling( i )*abs( theSum ) ; - big = dum ; - index_max = i ; - } - } - // Interchanging rows and the scale factor : - if( j!=index_max ) { - for( int k=0; k=0; i-- ) { - theSum = X( i ) ; - // theSum = B( i ) ; - theSum -= matrix_vector_product_sliced(LU, X, i, i+1, N) ; - // theSum -= sum( LU( i, Range( i+1, toEnd ) )*X( Range( i+1, toEnd ) ) ) ; - // theSum -= sum( LU( i, Range( i+1, toEnd ) )*B( Range( i+1, toEnd ) ) ) ; - // Store a component of the solution vector : - X( i ) = theSum/LU( i, i ) ; - // B( i ) = theSum/LU( i, i ) ; - } - - } - -}; - -#endif diff --git a/eigen3/bench/btl/libs/blitz/blitz_interface.hh b/eigen3/bench/btl/libs/blitz/blitz_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/blitz/blitz_interface.hh +++ /dev/null @@ -1,147 +0,0 @@ -//===================================================== -// File : blitz_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:30 CEST 2002 -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BLITZ_INTERFACE_HH -#define BLITZ_INTERFACE_HH - -#include -#include -#include -#include -#include -#include - -BZ_USING_NAMESPACE(blitz) - -template -class blitz_interface{ - -public : - - typedef real real_type ; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef blitz::Array gene_matrix; - typedef blitz::Array gene_vector; -// typedef blitz::Matrix gene_matrix; -// typedef blitz::Vector gene_vector; - - static inline std::string name() { return "blitz"; } - - static void free_matrix(gene_matrix & A, int N){} - - static void free_vector(gene_vector & B){} - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - A.resize(A_stl[0].size(),A_stl.size()); - for (int j=0; j(source); -// for (int i=0;i(source); - cible = source; - } - -}; - -#endif diff --git a/eigen3/bench/btl/libs/blitz/btl_blitz.cpp b/eigen3/bench/btl/libs/blitz/btl_blitz.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/blitz/btl_blitz.cpp +++ /dev/null @@ -1,51 +0,0 @@ -//===================================================== -// File : main.cpp -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:30 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "blitz_interface.hh" -#include "blitz_LU_solve_interface.hh" -#include "bench.hh" -#include "action_matrix_vector_product.hh" -#include "action_matrix_matrix_product.hh" -#include "action_axpy.hh" -#include "action_lu_solve.hh" -#include "action_ata_product.hh" -#include "action_aat_product.hh" -#include "action_atv_product.hh" - -BTL_MAIN; - -int main() -{ - - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - //bench > >(MIN_LU,MAX_LU,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/blitz/btl_tiny_blitz.cpp b/eigen3/bench/btl/libs/blitz/btl_tiny_blitz.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/blitz/btl_tiny_blitz.cpp +++ /dev/null @@ -1,38 +0,0 @@ -//===================================================== -// File : main.cpp -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:30 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "tiny_blitz_interface.hh" -#include "static/bench_static.hh" -#include "action_matrix_vector_product.hh" -#include "action_matrix_matrix_product.hh" -#include "action_axpy.hh" - -BTL_MAIN; - -int main() -{ - bench_static(); - bench_static(); - bench_static(); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/blitz/tiny_blitz_interface.hh b/eigen3/bench/btl/libs/blitz/tiny_blitz_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/blitz/tiny_blitz_interface.hh +++ /dev/null @@ -1,106 +0,0 @@ -//===================================================== -// File : tiny_blitz_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:30 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef TINY_BLITZ_INTERFACE_HH -#define TINY_BLITZ_INTERFACE_HH - -#include "blitz/array.h" -#include "blitz/tiny.h" -#include "blitz/tinymat.h" -#include "blitz/tinyvec.h" -#include - -#include - -BZ_USING_NAMESPACE(blitz) - -template -class tiny_blitz_interface -{ - -public : - - typedef real real_type ; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef TinyVector gene_vector; - typedef TinyMatrix gene_matrix; - - static inline std::string name() { return "tiny_blitz"; } - - static void free_matrix(gene_matrix & A, int N){} - - static void free_vector(gene_vector & B){} - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - for (int j=0; j -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen3_interface.hh" -#include "static/bench_static.hh" -#include "action_matrix_vector_product.hh" -#include "action_matrix_matrix_product.hh" -#include "action_axpy.hh" -#include "action_lu_solve.hh" -#include "action_ata_product.hh" -#include "action_aat_product.hh" -#include "action_atv_product.hh" -#include "action_cholesky.hh" -#include "action_trisolve.hh" - -BTL_MAIN; - -int main() -{ - - bench_static(); - bench_static(); - bench_static(); - bench_static(); - bench_static(); - bench_static(); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen2/eigen2_interface.hh b/eigen3/bench/btl/libs/eigen2/eigen2_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen2/eigen2_interface.hh +++ /dev/null @@ -1,168 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef EIGEN2_INTERFACE_HH -#define EIGEN2_INTERFACE_HH -// #include -#include -#include -#include -#include -#include -#include "btl.hh" - -using namespace Eigen; - -template -class eigen2_interface -{ - -public : - - enum {IsFixedSize = (SIZE!=Dynamic)}; - - typedef real real_type; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef Eigen::Matrix gene_matrix; - typedef Eigen::Matrix gene_vector; - - static inline std::string name( void ) - { - #if defined(EIGEN_VECTORIZE_SSE) - if (SIZE==Dynamic) return "eigen2"; else return "tiny_eigen2"; - #elif defined(EIGEN_VECTORIZE_ALTIVEC) - if (SIZE==Dynamic) return "eigen2"; else return "tiny_eigen2"; - #else - if (SIZE==Dynamic) return "eigen2_novec"; else return "tiny_eigen2_novec"; - #endif - } - - static void free_matrix(gene_matrix & A, int N) {} - - static void free_vector(gene_vector & B) {} - - static BTL_DONT_INLINE void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - A.resize(A_stl[0].size(), A_stl.size()); - - for (int j=0; j().solveTriangular(B); - } - - static inline void trisolve_lower_matrix(const gene_matrix & L, const gene_matrix& B, gene_matrix& X, int N){ - X = L.template marked().solveTriangular(B); - } - - static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){ - C = X.llt().matrixL(); -// C = X; -// Cholesky::computeInPlace(C); -// Cholesky::computeInPlaceBlock(C); - } - - static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, int N){ - C = X.lu().matrixLU(); -// C = X.inverse(); - } - - static inline void tridiagonalization(const gene_matrix & X, gene_matrix & C, int N){ - C = Tridiagonalization(X).packedMatrix(); - } - - static inline void hessenberg(const gene_matrix & X, gene_matrix & C, int N){ - C = HessenbergDecomposition(X).packedMatrix(); - } - - - -}; - -#endif diff --git a/eigen3/bench/btl/libs/eigen2/main_adv.cpp b/eigen3/bench/btl/libs/eigen2/main_adv.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen2/main_adv.cpp +++ /dev/null @@ -1,44 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen2_interface.hh" -#include "bench.hh" -#include "action_trisolve.hh" -#include "action_trisolve_matrix.hh" -#include "action_cholesky.hh" -#include "action_hessenberg.hh" -#include "action_lu_decomp.hh" -// #include "action_partial_lu.hh" - -BTL_MAIN; - -int main() -{ - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen2/main_linear.cpp b/eigen3/bench/btl/libs/eigen2/main_linear.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen2/main_linear.cpp +++ /dev/null @@ -1,34 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen2_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -BTL_MAIN; - -int main() -{ - - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen2/main_matmat.cpp b/eigen3/bench/btl/libs/eigen2/main_matmat.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen2/main_matmat.cpp +++ /dev/null @@ -1,35 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen2_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -BTL_MAIN; - -int main() -{ - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen2/main_vecmat.cpp b/eigen3/bench/btl/libs/eigen2/main_vecmat.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen2/main_vecmat.cpp +++ /dev/null @@ -1,36 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen2_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -BTL_MAIN; - -int main() -{ - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); -// bench > >(MIN_MV,MAX_MV,NB_POINT); -// bench > >(MIN_MV,MAX_MV,NB_POINT); -// bench > >(MIN_MV,MAX_MV,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen3/CMakeLists.txt b/eigen3/bench/btl/libs/eigen3/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen3/CMakeLists.txt +++ /dev/null @@ -1,65 +0,0 @@ - - -if((NOT EIGEN3_INCLUDE_DIR) AND Eigen_SOURCE_DIR) - # unless EIGEN3_INCLUDE_DIR is defined, let's use current Eigen version - set(EIGEN3_INCLUDE_DIR ${Eigen_SOURCE_DIR}) - set(EIGEN3_FOUND TRUE) -else() - find_package(Eigen3) -endif() - -if (EIGEN3_FOUND) - - include_directories(${EIGEN3_INCLUDE_DIR}) - btl_add_bench(btl_eigen3_linear main_linear.cpp) - btl_add_bench(btl_eigen3_vecmat main_vecmat.cpp) - btl_add_bench(btl_eigen3_matmat main_matmat.cpp) - btl_add_bench(btl_eigen3_adv main_adv.cpp ) - - btl_add_target_property(btl_eigen3_linear COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3") - btl_add_target_property(btl_eigen3_vecmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3") - btl_add_target_property(btl_eigen3_matmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3") - btl_add_target_property(btl_eigen3_adv COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3") - - option(BTL_BENCH_NOGCCVEC "also bench Eigen explicit vec without GCC's auto vec" OFF) - if(CMAKE_COMPILER_IS_GNUCXX AND BTL_BENCH_NOGCCVEC) - btl_add_bench(btl_eigen3_nogccvec_linear main_linear.cpp) - btl_add_bench(btl_eigen3_nogccvec_vecmat main_vecmat.cpp) - btl_add_bench(btl_eigen3_nogccvec_matmat main_matmat.cpp) - btl_add_bench(btl_eigen3_nogccvec_adv main_adv.cpp ) - - btl_add_target_property(btl_eigen3_nogccvec_linear COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec") - btl_add_target_property(btl_eigen3_nogccvec_vecmat COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec") - btl_add_target_property(btl_eigen3_nogccvec_matmat COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec") - btl_add_target_property(btl_eigen3_nogccvec_adv COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec") - endif() - - - if(NOT BTL_NOVEC) - btl_add_bench(btl_eigen3_novec_linear main_linear.cpp OFF) - btl_add_bench(btl_eigen3_novec_vecmat main_vecmat.cpp OFF) - btl_add_bench(btl_eigen3_novec_matmat main_matmat.cpp OFF) - btl_add_bench(btl_eigen3_novec_adv main_adv.cpp OFF) - btl_add_target_property(btl_eigen3_novec_linear COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec") - btl_add_target_property(btl_eigen3_novec_vecmat COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec") - btl_add_target_property(btl_eigen3_novec_matmat COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec") - btl_add_target_property(btl_eigen3_novec_adv COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec") - -# if(BUILD_btl_eigen3_adv) -# target_link_libraries(btl_eigen3_adv ${MKL_LIBRARIES}) -# endif(BUILD_btl_eigen3_adv) - - endif(NOT BTL_NOVEC) - - btl_add_bench(btl_tiny_eigen3 btl_tiny_eigen3.cpp OFF) - - if(NOT BTL_NOVEC) - btl_add_bench(btl_tiny_eigen3_novec btl_tiny_eigen3.cpp OFF) - btl_add_target_property(btl_tiny_eigen3_novec COMPILE_FLAGS "-DBTL_PREFIX=eigen3_tiny") - - if(BUILD_btl_tiny_eigen3_novec) - btl_add_target_property(btl_tiny_eigen3_novec COMPILE_FLAGS "-DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_tiny_novec") - endif(BUILD_btl_tiny_eigen3_novec) - endif(NOT BTL_NOVEC) - -endif (EIGEN3_FOUND) diff --git a/eigen3/bench/btl/libs/eigen3/btl_tiny_eigen3.cpp b/eigen3/bench/btl/libs/eigen3/btl_tiny_eigen3.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen3/btl_tiny_eigen3.cpp +++ /dev/null @@ -1,46 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen3_interface.hh" -#include "static/bench_static.hh" -#include "action_matrix_vector_product.hh" -#include "action_matrix_matrix_product.hh" -#include "action_axpy.hh" -#include "action_lu_solve.hh" -#include "action_ata_product.hh" -#include "action_aat_product.hh" -#include "action_atv_product.hh" -#include "action_cholesky.hh" -#include "action_trisolve.hh" - -BTL_MAIN; - -int main() -{ - - bench_static(); - bench_static(); - bench_static(); - bench_static(); - bench_static(); - bench_static(); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen3/eigen3_interface.hh b/eigen3/bench/btl/libs/eigen3/eigen3_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen3/eigen3_interface.hh +++ /dev/null @@ -1,240 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef EIGEN3_INTERFACE_HH -#define EIGEN3_INTERFACE_HH - -#include -#include -#include "btl.hh" - -using namespace Eigen; - -template -class eigen3_interface -{ - -public : - - enum {IsFixedSize = (SIZE!=Dynamic)}; - - typedef real real_type; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef Eigen::Matrix gene_matrix; - typedef Eigen::Matrix gene_vector; - - static inline std::string name( void ) - { - return EIGEN_MAKESTRING(BTL_PREFIX); - } - - static void free_matrix(gene_matrix & A, int N) {} - - static void free_vector(gene_vector & B) {} - - static BTL_DONT_INLINE void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - A.resize(A_stl[0].size(), A_stl.size()); - - for (int j=0; j().setZero(); - X.template selfadjointView().rankUpdate(A); - } - - static inline void matrix_vector_product(const gene_matrix & A, const gene_vector & B, gene_vector & X, int N){ - X.noalias() = A*B; - } - - static inline void symv(const gene_matrix & A, const gene_vector & B, gene_vector & X, int N){ - X.noalias() = (A.template selfadjointView() * B); -// internal::product_selfadjoint_vector(N,A.data(),N, B.data(), 1, X.data(), 1); - } - - template static void triassign(Dest& dst, const Src& src) - { - typedef typename Dest::Scalar Scalar; - typedef typename internal::packet_traits::type Packet; - const int PacketSize = sizeof(Packet)/sizeof(Scalar); - int size = dst.cols(); - for(int j=0; j(j, index, src); - else - dst.template copyPacket(index, j, src); - } - - // do the non-vectorizable part of the assignment - for (int index = alignedEnd; index(N,A.data(),N, X.data(), 1, Y.data(), 1, -1); - for(int j=0; j(c,s)); - } - - static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ - X.noalias() = (A.transpose()*B); - } - - static inline void axpy(real coef, const gene_vector & X, gene_vector & Y, int N){ - Y += coef * X; - } - - static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int N){ - Y = a*X + b*Y; - } - - static EIGEN_DONT_INLINE void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){ - cible = source; - } - - static EIGEN_DONT_INLINE void copy_vector(const gene_vector & source, gene_vector & cible, int N){ - cible = source; - } - - static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector& X, int N){ - X = L.template triangularView().solve(B); - } - - static inline void trisolve_lower_matrix(const gene_matrix & L, const gene_matrix& B, gene_matrix& X, int N){ - X = L.template triangularView().solve(B); - } - - static inline void trmm(const gene_matrix & L, const gene_matrix& B, gene_matrix& X, int N){ - X.noalias() = L.template triangularView() * B; - } - - static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){ - C = X; - internal::llt_inplace::blocked(C); - //C = X.llt().matrixL(); -// C = X; -// Cholesky::computeInPlace(C); -// Cholesky::computeInPlaceBlock(C); - } - - static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, int N){ - C = X.fullPivLu().matrixLU(); - } - - static inline void partial_lu_decomp(const gene_matrix & X, gene_matrix & C, int N){ - Matrix piv(N); - DenseIndex nb; - C = X; - internal::partial_lu_inplace(C,piv,nb); -// C = X.partialPivLu().matrixLU(); - } - - static inline void tridiagonalization(const gene_matrix & X, gene_matrix & C, int N){ - typename Tridiagonalization::CoeffVectorType aux(N-1); - C = X; - internal::tridiagonalization_inplace(C, aux); - } - - static inline void hessenberg(const gene_matrix & X, gene_matrix & C, int N){ - C = HessenbergDecomposition(X).packedMatrix(); - } - - - -}; - -#endif diff --git a/eigen3/bench/btl/libs/eigen3/main_adv.cpp b/eigen3/bench/btl/libs/eigen3/main_adv.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen3/main_adv.cpp +++ /dev/null @@ -1,44 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen3_interface.hh" -#include "bench.hh" -#include "action_trisolve.hh" -#include "action_trisolve_matrix.hh" -#include "action_cholesky.hh" -#include "action_hessenberg.hh" -#include "action_lu_decomp.hh" -#include "action_partial_lu.hh" - -BTL_MAIN; - -int main() -{ - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen3/main_linear.cpp b/eigen3/bench/btl/libs/eigen3/main_linear.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen3/main_linear.cpp +++ /dev/null @@ -1,35 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen3_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -BTL_MAIN; - -int main() -{ - - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen3/main_matmat.cpp b/eigen3/bench/btl/libs/eigen3/main_matmat.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen3/main_matmat.cpp +++ /dev/null @@ -1,35 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen3_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -BTL_MAIN; - -int main() -{ - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/eigen3/main_vecmat.cpp b/eigen3/bench/btl/libs/eigen3/main_vecmat.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/eigen3/main_vecmat.cpp +++ /dev/null @@ -1,36 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "eigen3_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -BTL_MAIN; - -int main() -{ - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/gmm/CMakeLists.txt b/eigen3/bench/btl/libs/gmm/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/libs/gmm/CMakeLists.txt +++ /dev/null @@ -1,6 +0,0 @@ - -find_package(GMM) -if (GMM_FOUND) - include_directories(${GMM_INCLUDES}) - btl_add_bench(btl_gmm main.cpp) -endif (GMM_FOUND) diff --git a/eigen3/bench/btl/libs/gmm/gmm_LU_solve_interface.hh b/eigen3/bench/btl/libs/gmm/gmm_LU_solve_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/gmm/gmm_LU_solve_interface.hh +++ /dev/null @@ -1,192 +0,0 @@ -//===================================================== -// File : blitz_LU_solve_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:31 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BLITZ_LU_SOLVE_INTERFACE_HH -#define BLITZ_LU_SOLVE_INTERFACE_HH - -#include "blitz/array.h" -#include - -BZ_USING_NAMESPACE(blitz) - -template -class blitz_LU_solve_interface : public blitz_interface -{ - -public : - - typedef typename blitz_interface::gene_matrix gene_matrix; - typedef typename blitz_interface::gene_vector gene_vector; - - typedef blitz::Array Pivot_Vector; - - inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N) - { - - pivot.resize(N); - - } - - inline static void free_Pivot_Vector(Pivot_Vector & pivot) - { - - return; - - } - - - static inline real matrix_vector_product_sliced(const gene_matrix & A, gene_vector B, int row, int col_start, int col_end) - { - - real somme=0.; - - for (int j=col_start ; j=big ) big = abs( LU( i, j ) ) ; - } - if( big==0. ) { - INFOS( "blitz_LU_factor::Singular matrix" ) ; - exit( 0 ) ; - } - ImplicitScaling( i ) = 1./big ; - } - // Loop over columns of Crout's method : - for( int j=0; j=big ) { - dum = ImplicitScaling( i )*abs( theSum ) ; - big = dum ; - index_max = i ; - } - } - // Interchanging rows and the scale factor : - if( j!=index_max ) { - for( int k=0; k=0; i-- ) { - theSum = X( i ) ; - // theSum = B( i ) ; - theSum -= matrix_vector_product_sliced(LU, X, i, i+1, N) ; - // theSum -= sum( LU( i, Range( i+1, toEnd ) )*X( Range( i+1, toEnd ) ) ) ; - // theSum -= sum( LU( i, Range( i+1, toEnd ) )*B( Range( i+1, toEnd ) ) ) ; - // Store a component of the solution vector : - X( i ) = theSum/LU( i, i ) ; - // B( i ) = theSum/LU( i, i ) ; - } - - } - -}; - -#endif diff --git a/eigen3/bench/btl/libs/gmm/gmm_interface.hh b/eigen3/bench/btl/libs/gmm/gmm_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/gmm/gmm_interface.hh +++ /dev/null @@ -1,144 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef GMM_INTERFACE_HH -#define GMM_INTERFACE_HH - -#include -#include - -using namespace gmm; - -template -class gmm_interface { - -public : - - typedef real real_type ; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef gmm::dense_matrix gene_matrix; - typedef stl_vector gene_vector; - - static inline std::string name( void ) - { - return "gmm"; - } - - static void free_matrix(gene_matrix & A, int N){ - return ; - } - - static void free_vector(gene_vector & B){ - return ; - } - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - A.resize(A_stl[0].size(),A_stl.size()); - - for (int j=0; j ipvt(N); - gmm::lu_factor(R, ipvt); - } - - static inline void hessenberg(const gene_matrix & X, gene_matrix & R, int N){ - gmm::copy(X,R); - gmm::Hessenberg_reduction(R,X,false); - } - - static inline void tridiagonalization(const gene_matrix & X, gene_matrix & R, int N){ - gmm::copy(X,R); - gmm::Householder_tridiagonalization(R,X,false); - } - -}; - -#endif diff --git a/eigen3/bench/btl/libs/gmm/main.cpp b/eigen3/bench/btl/libs/gmm/main.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/gmm/main.cpp +++ /dev/null @@ -1,51 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "gmm_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" -#include "action_hessenberg.hh" -#include "action_partial_lu.hh" - -BTL_MAIN; - -int main() -{ - - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - //bench > >(MIN_LU,MAX_LU,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/mtl4/.kdbgrc.main b/eigen3/bench/btl/libs/mtl4/.kdbgrc.main deleted file mode 100644 --- a/eigen3/bench/btl/libs/mtl4/.kdbgrc.main +++ /dev/null @@ -1,12 +0,0 @@ -[General] -DebuggerCmdStr= -DriverName=GDB -FileVersion=1 -OptionsSelected= -ProgramArgs= -TTYLevel=7 -WorkingDirectory= - -[Memory] -ColumnWidths=80,0 -NumExprs=0 diff --git a/eigen3/bench/btl/libs/mtl4/CMakeLists.txt b/eigen3/bench/btl/libs/mtl4/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/libs/mtl4/CMakeLists.txt +++ /dev/null @@ -1,6 +0,0 @@ - -find_package(MTL4) -if (MTL4_FOUND) - include_directories(${MTL4_INCLUDE_DIR}) - btl_add_bench(btl_mtl4 main.cpp) -endif (MTL4_FOUND) diff --git a/eigen3/bench/btl/libs/mtl4/main.cpp b/eigen3/bench/btl/libs/mtl4/main.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/mtl4/main.cpp +++ /dev/null @@ -1,46 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "mtl4_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" -#include "action_cholesky.hh" -// #include "action_lu_decomp.hh" - -BTL_MAIN; - -int main() -{ - - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/mtl4/mtl4_LU_solve_interface.hh b/eigen3/bench/btl/libs/mtl4/mtl4_LU_solve_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/mtl4/mtl4_LU_solve_interface.hh +++ /dev/null @@ -1,192 +0,0 @@ -//===================================================== -// File : blitz_LU_solve_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:31 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef BLITZ_LU_SOLVE_INTERFACE_HH -#define BLITZ_LU_SOLVE_INTERFACE_HH - -#include "blitz/array.h" -#include - -BZ_USING_NAMESPACE(blitz) - -template -class blitz_LU_solve_interface : public blitz_interface -{ - -public : - - typedef typename blitz_interface::gene_matrix gene_matrix; - typedef typename blitz_interface::gene_vector gene_vector; - - typedef blitz::Array Pivot_Vector; - - inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N) - { - - pivot.resize(N); - - } - - inline static void free_Pivot_Vector(Pivot_Vector & pivot) - { - - return; - - } - - - static inline real matrix_vector_product_sliced(const gene_matrix & A, gene_vector B, int row, int col_start, int col_end) - { - - real somme=0.; - - for (int j=col_start ; j=big ) big = abs( LU( i, j ) ) ; - } - if( big==0. ) { - INFOS( "blitz_LU_factor::Singular matrix" ) ; - exit( 0 ) ; - } - ImplicitScaling( i ) = 1./big ; - } - // Loop over columns of Crout's method : - for( int j=0; j=big ) { - dum = ImplicitScaling( i )*abs( theSum ) ; - big = dum ; - index_max = i ; - } - } - // Interchanging rows and the scale factor : - if( j!=index_max ) { - for( int k=0; k=0; i-- ) { - theSum = X( i ) ; - // theSum = B( i ) ; - theSum -= matrix_vector_product_sliced(LU, X, i, i+1, N) ; - // theSum -= sum( LU( i, Range( i+1, toEnd ) )*X( Range( i+1, toEnd ) ) ) ; - // theSum -= sum( LU( i, Range( i+1, toEnd ) )*B( Range( i+1, toEnd ) ) ) ; - // Store a component of the solution vector : - X( i ) = theSum/LU( i, i ) ; - // B( i ) = theSum/LU( i, i ) ; - } - - } - -}; - -#endif diff --git a/eigen3/bench/btl/libs/mtl4/mtl4_interface.hh b/eigen3/bench/btl/libs/mtl4/mtl4_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/mtl4/mtl4_interface.hh +++ /dev/null @@ -1,144 +0,0 @@ -//===================================================== -// Copyright (C) 2008 Gael Guennebaud -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef MTL4_INTERFACE_HH -#define MTL4_INTERFACE_HH - -#include -#include -// #include -#include - -using namespace mtl; - -template -class mtl4_interface { - -public : - - typedef real real_type ; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef mtl::dense2D > gene_matrix; - typedef mtl::dense_vector gene_vector; - - static inline std::string name() { return "mtl4"; } - - static void free_matrix(gene_matrix & A, int N){ - return ; - } - - static void free_vector(gene_vector & B){ - return ; - } - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - A.change_dim(A_stl[0].size(), A_stl.size()); - - for (int j=0; j C(N,N); -// C = B; -// X = (A*C); - } - - static inline void transposed_matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){ - X = (trans(A)*trans(B)); - } - -// static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N){ -// X = (trans(A)*A); -// } - - static inline void aat_product(const gene_matrix & A, gene_matrix & X, int N){ - X = (A*trans(A)); - } - - static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ - X = (A*B); - } - - static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ - X = (trans(A)*B); - } - - static inline void axpy(const real coef, const gene_vector & X, gene_vector & Y, int N){ - Y += coef * X; - } - - static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int N){ - Y = a*X + b*Y; - } - -// static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){ -// C = X; -// recursive_cholesky(C); -// } - -// static inline void lu_decomp(const gene_matrix & X, gene_matrix & R, int N){ -// R = X; -// std::vector ipvt(N); -// lu_factor(R, ipvt); -// } - - static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector & X, int N){ - X = lower_trisolve(L, B); - } - - static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){ - cible = source; - } - - static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){ - cible = source; - } - -}; - -#endif diff --git a/eigen3/bench/btl/libs/tvmet/CMakeLists.txt b/eigen3/bench/btl/libs/tvmet/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/btl/libs/tvmet/CMakeLists.txt +++ /dev/null @@ -1,6 +0,0 @@ - -find_package(Tvmet) -if (TVMET_FOUND) - include_directories(${TVMET_INCLUDE_DIR}) - btl_add_bench(btl_tvmet main.cpp OFF) -endif (TVMET_FOUND) diff --git a/eigen3/bench/btl/libs/tvmet/main.cpp b/eigen3/bench/btl/libs/tvmet/main.cpp deleted file mode 100644 --- a/eigen3/bench/btl/libs/tvmet/main.cpp +++ /dev/null @@ -1,40 +0,0 @@ -//===================================================== -// File : main.cpp -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:30 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "tvmet_interface.hh" -#include "static/bench_static.hh" -#include "action_matrix_vector_product.hh" -#include "action_matrix_matrix_product.hh" -#include "action_atv_product.hh" -#include "action_axpy.hh" - -BTL_MAIN; - -int main() -{ - bench_static(); - bench_static(); - bench_static(); - bench_static(); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/tvmet/tvmet_interface.hh b/eigen3/bench/btl/libs/tvmet/tvmet_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/tvmet/tvmet_interface.hh +++ /dev/null @@ -1,104 +0,0 @@ -//===================================================== -// File : tvmet_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:30 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef TVMET_INTERFACE_HH -#define TVMET_INTERFACE_HH - -#include -#include -#include - -#include - -using namespace tvmet; - -template -class tvmet_interface{ - -public : - - typedef real real_type ; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef Vector gene_vector; - typedef Matrix gene_matrix; - - static inline std::string name() { return "tiny_tvmet"; } - - static void free_matrix(gene_matrix & A, int N){} - - static void free_vector(gene_vector & B){} - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - for (int j=0; j -// Copyright (C) EDF R&D, lun sep 30 14:23:27 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#include "utilities.h" -#include "ublas_interface.hh" -#include "bench.hh" -#include "basic_actions.hh" - -BTL_MAIN; - -int main() -{ - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - bench > >(MIN_AXPY,MAX_AXPY,NB_POINT); - - bench > >(MIN_MV,MAX_MV,NB_POINT); - bench > >(MIN_MV,MAX_MV,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); -// bench > >(MIN_MM,MAX_MM,NB_POINT); - - bench > >(MIN_MM,MAX_MM,NB_POINT); - - return 0; -} - - diff --git a/eigen3/bench/btl/libs/ublas/ublas_interface.hh b/eigen3/bench/btl/libs/ublas/ublas_interface.hh deleted file mode 100644 --- a/eigen3/bench/btl/libs/ublas/ublas_interface.hh +++ /dev/null @@ -1,141 +0,0 @@ -//===================================================== -// File : ublas_interface.hh -// Author : L. Plagne -// Copyright (C) EDF R&D, lun sep 30 14:23:27 CEST 2002 -//===================================================== -// -// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -#ifndef UBLAS_INTERFACE_HH -#define UBLAS_INTERFACE_HH - -#include -#include -#include -#include - -using namespace boost::numeric; - -template -class ublas_interface{ - -public : - - typedef real real_type ; - - typedef std::vector stl_vector; - typedef std::vector stl_matrix; - - typedef typename boost::numeric::ublas::matrix gene_matrix; - typedef typename boost::numeric::ublas::vector gene_vector; - - static inline std::string name( void ) { return "ublas"; } - - static void free_matrix(gene_matrix & A, int N) {} - - static void free_vector(gene_vector & B) {} - - static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ - A.resize(A_stl.size(),A_stl[0].size()); - for (int j=0; j -#include "../Eigen/Core" - -using namespace Eigen; -using namespace std; - -#define DUMP_CPUID(CODE) {\ - int abcd[4]; \ - abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;\ - EIGEN_CPUID(abcd, CODE, 0); \ - std::cout << "The code " << CODE << " gives " \ - << (int*)(abcd[0]) << " " << (int*)(abcd[1]) << " " \ - << (int*)(abcd[2]) << " " << (int*)(abcd[3]) << " " << std::endl; \ - } - -int main() -{ - cout << "Eigen's L1 = " << internal::queryL1CacheSize() << endl; - cout << "Eigen's L2/L3 = " << internal::queryTopLevelCacheSize() << endl; - int l1, l2, l3; - internal::queryCacheSizes(l1, l2, l3); - cout << "Eigen's L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; - - #ifdef EIGEN_CPUID - - int abcd[4]; - int string[8]; - char* string_char = (char*)(string); - - // vendor ID - EIGEN_CPUID(abcd,0x0,0); - string[0] = abcd[1]; - string[1] = abcd[3]; - string[2] = abcd[2]; - string[3] = 0; - cout << endl; - cout << "vendor id = " << string_char << endl; - cout << endl; - int max_funcs = abcd[0]; - - internal::queryCacheSizes_intel_codes(l1, l2, l3); - cout << "Eigen's intel codes L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; - if(max_funcs>=4) - { - internal::queryCacheSizes_intel_direct(l1, l2, l3); - cout << "Eigen's intel direct L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; - } - internal::queryCacheSizes_amd(l1, l2, l3); - cout << "Eigen's amd L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; - cout << endl; - - // dump Intel direct method - if(max_funcs>=4) - { - l1 = l2 = l3 = 0; - int cache_id = 0; - int cache_type = 0; - do { - abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0; - EIGEN_CPUID(abcd,0x4,cache_id); - cache_type = (abcd[0] & 0x0F) >> 0; - int cache_level = (abcd[0] & 0xE0) >> 5; // A[7:5] - int ways = (abcd[1] & 0xFFC00000) >> 22; // B[31:22] - int partitions = (abcd[1] & 0x003FF000) >> 12; // B[21:12] - int line_size = (abcd[1] & 0x00000FFF) >> 0; // B[11:0] - int sets = (abcd[2]); // C[31:0] - int cache_size = (ways+1) * (partitions+1) * (line_size+1) * (sets+1); - - cout << "cache[" << cache_id << "].type = " << cache_type << "\n"; - cout << "cache[" << cache_id << "].level = " << cache_level << "\n"; - cout << "cache[" << cache_id << "].ways = " << ways << "\n"; - cout << "cache[" << cache_id << "].partitions = " << partitions << "\n"; - cout << "cache[" << cache_id << "].line_size = " << line_size << "\n"; - cout << "cache[" << cache_id << "].sets = " << sets << "\n"; - cout << "cache[" << cache_id << "].size = " << cache_size << "\n"; - - cache_id++; - } while(cache_type>0 && cache_id<16); - } - - // dump everything - std::cout << endl <<"Raw dump:" << endl; - for(int i=0; i -// -// This Source Code Form is subject to the terms of the Mozilla -// Public License v. 2.0. If a copy of the MPL was not distributed -// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. - -// The computeRoots function included in this is based on materials -// covered by the following copyright and license: -// -// Geometric Tools, LLC -// Copyright (c) 1998-2010 -// Distributed under the Boost Software License, Version 1.0. -// -// Permission is hereby granted, free of charge, to any person or organization -// obtaining a copy of the software and accompanying documentation covered by -// this license (the "Software") to use, reproduce, display, distribute, -// execute, and transmit the Software, and to prepare derivative works of the -// Software, and to permit third-parties to whom the Software is furnished to -// do so, all subject to the following: -// -// The copyright notices in the Software and this entire statement, including -// the above license grant, this restriction and the following disclaimer, -// must be included in all copies of the Software, in whole or in part, and -// all derivative works of the Software, unless such copies or derivative -// works are solely in the form of machine-executable object code generated by -// a source language processor. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT -// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE -// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, -// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - -#include -#include -#include -#include -#include - -using namespace Eigen; -using namespace std; - -template -inline void computeRoots(const Matrix& m, Roots& roots) -{ - typedef typename Matrix::Scalar Scalar; - const Scalar s_inv3 = 1.0/3.0; - const Scalar s_sqrt3 = internal::sqrt(Scalar(3.0)); - - // The characteristic equation is x^3 - c2*x^2 + c1*x - c0 = 0. The - // eigenvalues are the roots to this equation, all guaranteed to be - // real-valued, because the matrix is symmetric. - Scalar c0 = m(0,0)*m(1,1)*m(2,2) + Scalar(2)*m(0,1)*m(0,2)*m(1,2) - m(0,0)*m(1,2)*m(1,2) - m(1,1)*m(0,2)*m(0,2) - m(2,2)*m(0,1)*m(0,1); - Scalar c1 = m(0,0)*m(1,1) - m(0,1)*m(0,1) + m(0,0)*m(2,2) - m(0,2)*m(0,2) + m(1,1)*m(2,2) - m(1,2)*m(1,2); - Scalar c2 = m(0,0) + m(1,1) + m(2,2); - - // Construct the parameters used in classifying the roots of the equation - // and in solving the equation for the roots in closed form. - Scalar c2_over_3 = c2*s_inv3; - Scalar a_over_3 = (c1 - c2*c2_over_3)*s_inv3; - if (a_over_3 > Scalar(0)) - a_over_3 = Scalar(0); - - Scalar half_b = Scalar(0.5)*(c0 + c2_over_3*(Scalar(2)*c2_over_3*c2_over_3 - c1)); - - Scalar q = half_b*half_b + a_over_3*a_over_3*a_over_3; - if (q > Scalar(0)) - q = Scalar(0); - - // Compute the eigenvalues by solving for the roots of the polynomial. - Scalar rho = internal::sqrt(-a_over_3); - Scalar theta = std::atan2(internal::sqrt(-q),half_b)*s_inv3; - Scalar cos_theta = internal::cos(theta); - Scalar sin_theta = internal::sin(theta); - roots(0) = c2_over_3 + Scalar(2)*rho*cos_theta; - roots(1) = c2_over_3 - rho*(cos_theta + s_sqrt3*sin_theta); - roots(2) = c2_over_3 - rho*(cos_theta - s_sqrt3*sin_theta); - - // Sort in increasing order. - if (roots(0) >= roots(1)) - std::swap(roots(0),roots(1)); - if (roots(1) >= roots(2)) - { - std::swap(roots(1),roots(2)); - if (roots(0) >= roots(1)) - std::swap(roots(0),roots(1)); - } -} - -template -void eigen33(const Matrix& mat, Matrix& evecs, Vector& evals) -{ - typedef typename Matrix::Scalar Scalar; - // Scale the matrix so its entries are in [-1,1]. The scaling is applied - // only when at least one matrix entry has magnitude larger than 1. - - Scalar scale = mat.cwiseAbs()/*.template triangularView()*/.maxCoeff(); - scale = std::max(scale,Scalar(1)); - Matrix scaledMat = mat / scale; - - // Compute the eigenvalues -// scaledMat.setZero(); - computeRoots(scaledMat,evals); - - // compute the eigen vectors - // **here we assume 3 differents eigenvalues** - - // "optimized version" which appears to be slower with gcc! -// Vector base; -// Scalar alpha, beta; -// base << scaledMat(1,0) * scaledMat(2,1), -// scaledMat(1,0) * scaledMat(2,0), -// -scaledMat(1,0) * scaledMat(1,0); -// for(int k=0; k<2; ++k) -// { -// alpha = scaledMat(0,0) - evals(k); -// beta = scaledMat(1,1) - evals(k); -// evecs.col(k) = (base + Vector(-beta*scaledMat(2,0), -alpha*scaledMat(2,1), alpha*beta)).normalized(); -// } -// evecs.col(2) = evecs.col(0).cross(evecs.col(1)).normalized(); - -// // naive version -// Matrix tmp; -// tmp = scaledMat; -// tmp.diagonal().array() -= evals(0); -// evecs.col(0) = tmp.row(0).cross(tmp.row(1)).normalized(); -// -// tmp = scaledMat; -// tmp.diagonal().array() -= evals(1); -// evecs.col(1) = tmp.row(0).cross(tmp.row(1)).normalized(); -// -// tmp = scaledMat; -// tmp.diagonal().array() -= evals(2); -// evecs.col(2) = tmp.row(0).cross(tmp.row(1)).normalized(); - - // a more stable version: - if((evals(2)-evals(0))<=Eigen::NumTraits::epsilon()) - { - evecs.setIdentity(); - } - else - { - Matrix tmp; - tmp = scaledMat; - tmp.diagonal ().array () -= evals (2); - evecs.col (2) = tmp.row (0).cross (tmp.row (1)).normalized (); - - tmp = scaledMat; - tmp.diagonal ().array () -= evals (1); - evecs.col(1) = tmp.row (0).cross(tmp.row (1)); - Scalar n1 = evecs.col(1).norm(); - if(n1<=Eigen::NumTraits::epsilon()) - evecs.col(1) = evecs.col(2).unitOrthogonal(); - else - evecs.col(1) /= n1; - - // make sure that evecs[1] is orthogonal to evecs[2] - evecs.col(1) = evecs.col(2).cross(evecs.col(1).cross(evecs.col(2))).normalized(); - evecs.col(0) = evecs.col(2).cross(evecs.col(1)); - } - - // Rescale back to the original size. - evals *= scale; -} - -int main() -{ - BenchTimer t; - int tries = 10; - int rep = 400000; - typedef Matrix3f Mat; - typedef Vector3f Vec; - Mat A = Mat::Random(3,3); - A = A.adjoint() * A; - - SelfAdjointEigenSolver eig(A); - BENCH(t, tries, rep, eig.compute(A)); - std::cout << "Eigen: " << t.best() << "s\n"; - - Mat evecs; - Vec evals; - BENCH(t, tries, rep, eigen33(A,evecs,evals)); - std::cout << "Direct: " << t.best() << "s\n\n"; - - std::cerr << "Eigenvalue/eigenvector diffs:\n"; - std::cerr << (evals - eig.eigenvalues()).transpose() << "\n"; - for(int k=0;k<3;++k) - if(evecs.col(k).dot(eig.eigenvectors().col(k))<0) - evecs.col(k) = -evecs.col(k); - std::cerr << evecs - eig.eigenvectors() << "\n\n"; -} diff --git a/eigen3/bench/geometry.cpp b/eigen3/bench/geometry.cpp deleted file mode 100644 --- a/eigen3/bench/geometry.cpp +++ /dev/null @@ -1,126 +0,0 @@ - -#include -#include -#include - -using namespace std; -using namespace Eigen; - -#ifndef SCALAR -#define SCALAR float -#endif - -#ifndef SIZE -#define SIZE 8 -#endif - -typedef SCALAR Scalar; -typedef NumTraits::Real RealScalar; -typedef Matrix A; -typedef Matrix B; -typedef Matrix C; -typedef Matrix M; - -template -EIGEN_DONT_INLINE void transform(const Transformation& t, Data& data) -{ - EIGEN_ASM_COMMENT("begin"); - data = t * data; - EIGEN_ASM_COMMENT("end"); -} - -template -EIGEN_DONT_INLINE void transform(const Quaternion& t, Data& data) -{ - EIGEN_ASM_COMMENT("begin quat"); - for(int i=0;i struct ToRotationMatrixWrapper -{ - enum {Dim = T::Dim}; - typedef typename T::Scalar Scalar; - ToRotationMatrixWrapper(const T& o) : object(o) {} - T object; -}; - -template -EIGEN_DONT_INLINE void transform(const ToRotationMatrixWrapper& t, Data& data) -{ - EIGEN_ASM_COMMENT("begin quat via mat"); - data = t.object.toRotationMatrix() * data; - EIGEN_ASM_COMMENT("end quat via mat"); -} - -template -EIGEN_DONT_INLINE void transform(const Transform& t, Data& data) -{ - data = (t * data.colwise().homogeneous()).template block(0,0); -} - -template struct get_dim { enum { Dim = T::Dim }; }; -template -struct get_dim > { enum { Dim = R }; }; - -template -struct bench_impl -{ - static EIGEN_DONT_INLINE void run(const Transformation& t) - { - Matrix::Dim,N> data; - data.setRandom(); - bench_impl::run(t); - BenchTimer timer; - BENCH(timer,10,100000,transform(t,data)); - cout.width(9); - cout << timer.best() << " "; - } -}; - - -template -struct bench_impl -{ - static EIGEN_DONT_INLINE void run(const Transformation&) {} -}; - -template -EIGEN_DONT_INLINE void bench(const std::string& msg, const Transformation& t) -{ - cout << msg << " "; - bench_impl::run(t); - std::cout << "\n"; -} - -int main(int argc, char ** argv) -{ - Matrix mat34; mat34.setRandom(); - Transform iso3(mat34); - Transform aff3(mat34); - Transform caff3(mat34); - Transform proj3(mat34); - Quaternion quat;quat.setIdentity(); - ToRotationMatrixWrapper > quatmat(quat); - Matrix mat33; mat33.setRandom(); - - cout.precision(4); - std::cout - << "N "; - for(int i=0;i -#include -#include - -using namespace Eigen; -using namespace std; - -#define END 9 - -template struct map_size { enum { ret = S }; }; -template<> struct map_size<10> { enum { ret = 20 }; }; -template<> struct map_size<11> { enum { ret = 50 }; }; -template<> struct map_size<12> { enum { ret = 100 }; }; -template<> struct map_size<13> { enum { ret = 300 }; }; - -template struct alt_prod -{ - enum { - ret = M==1 && N==1 ? InnerProduct - : K==1 ? OuterProduct - : M==1 ? GemvProduct - : N==1 ? GemvProduct - : GemmProduct - }; -}; - -void print_mode(int mode) -{ - if(mode==InnerProduct) std::cout << "i"; - if(mode==OuterProduct) std::cout << "o"; - if(mode==CoeffBasedProductMode) std::cout << "c"; - if(mode==LazyCoeffBasedProductMode) std::cout << "l"; - if(mode==GemvProduct) std::cout << "v"; - if(mode==GemmProduct) std::cout << "m"; -} - -template -EIGEN_DONT_INLINE void prod(const Lhs& a, const Rhs& b, Res& c) -{ - c.noalias() += typename ProductReturnType::Type(a,b); -} - -template -EIGEN_DONT_INLINE void bench_prod() -{ - typedef Matrix Lhs; Lhs a; a.setRandom(); - typedef Matrix Rhs; Rhs b; b.setRandom(); - typedef Matrix Res; Res c; c.setRandom(); - - BenchTimer t; - double n = 2.*double(M)*double(N)*double(K); - int rep = 100000./n; - rep /= 2; - if(rep<1) rep = 1; - do { - rep *= 2; - t.reset(); - BENCH(t,1,rep,prod(a,b,c)); - } while(t.best()<0.1); - - t.reset(); - BENCH(t,5,rep,prod(a,b,c)); - - print_mode(Mode); - std::cout << int(1e-6*n*rep/t.best()) << "\t"; -} - -template struct print_n; -template struct loop_on_m; -template struct loop_on_n; - -template -struct loop_on_k -{ - static void run() - { - std::cout << "K=" << K << "\t"; - print_n::run(); - std::cout << "\n"; - - loop_on_m::run(); - std::cout << "\n\n"; - - loop_on_k::run(); - } -}; - -template -struct loop_on_k { static void run(){} }; - - -template -struct loop_on_m -{ - static void run() - { - std::cout << M << "f\t"; - loop_on_n::run(); - std::cout << "\n"; - - std::cout << M << "f\t"; - loop_on_n::run(); - std::cout << "\n"; - - loop_on_m::run(); - } -}; - -template -struct loop_on_m { static void run(){} }; - -template -struct loop_on_n -{ - static void run() - { - bench_prod::ret : Mode>(); - - loop_on_n::run(); - } -}; - -template -struct loop_on_n { static void run(){} }; - -template struct print_n -{ - static void run() - { - std::cout << map_size::ret << "\t"; - print_n::run(); - } -}; - -template<> struct print_n { static void run(){} }; - -int main() -{ - loop_on_k<1,1,1>::run(); - - return 0; -} diff --git a/eigen3/bench/quat_slerp.cpp b/eigen3/bench/quat_slerp.cpp deleted file mode 100644 --- a/eigen3/bench/quat_slerp.cpp +++ /dev/null @@ -1,247 +0,0 @@ - -#include -#include -#include -using namespace Eigen; -using namespace std; - - - -template -EIGEN_DONT_INLINE Q nlerp(const Q& a, const Q& b, typename Q::Scalar t) -{ - return Q((a.coeffs() * (1.0-t) + b.coeffs() * t).normalized()); -} - -template -EIGEN_DONT_INLINE Q slerp_eigen(const Q& a, const Q& b, typename Q::Scalar t) -{ - return a.slerp(t,b); -} - -template -EIGEN_DONT_INLINE Q slerp_legacy(const Q& a, const Q& b, typename Q::Scalar t) -{ - typedef typename Q::Scalar Scalar; - static const Scalar one = Scalar(1) - dummy_precision(); - Scalar d = a.dot(b); - Scalar absD = internal::abs(d); - if (absD>=one) - return a; - - // theta is the angle between the 2 quaternions - Scalar theta = std::acos(absD); - Scalar sinTheta = internal::sin(theta); - - Scalar scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta; - Scalar scale1 = internal::sin( ( t * theta) ) / sinTheta; - if (d<0) - scale1 = -scale1; - - return Q(scale0 * a.coeffs() + scale1 * b.coeffs()); -} - -template -EIGEN_DONT_INLINE Q slerp_legacy_nlerp(const Q& a, const Q& b, typename Q::Scalar t) -{ - typedef typename Q::Scalar Scalar; - static const Scalar one = Scalar(1) - epsilon(); - Scalar d = a.dot(b); - Scalar absD = internal::abs(d); - - Scalar scale0; - Scalar scale1; - - if (absD>=one) - { - scale0 = Scalar(1) - t; - scale1 = t; - } - else - { - // theta is the angle between the 2 quaternions - Scalar theta = std::acos(absD); - Scalar sinTheta = internal::sin(theta); - - scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta; - scale1 = internal::sin( ( t * theta) ) / sinTheta; - if (d<0) - scale1 = -scale1; - } - - return Q(scale0 * a.coeffs() + scale1 * b.coeffs()); -} - -template -inline T sin_over_x(T x) -{ - if (T(1) + x*x == T(1)) - return T(1); - else - return std::sin(x)/x; -} - -template -EIGEN_DONT_INLINE Q slerp_rw(const Q& a, const Q& b, typename Q::Scalar t) -{ - typedef typename Q::Scalar Scalar; - - Scalar d = a.dot(b); - Scalar theta; - if (d<0.0) - theta = /*M_PI -*/ Scalar(2)*std::asin( (a.coeffs()+b.coeffs()).norm()/2 ); - else - theta = Scalar(2)*std::asin( (a.coeffs()-b.coeffs()).norm()/2 ); - - // theta is the angle between the 2 quaternions -// Scalar theta = std::acos(absD); - Scalar sinOverTheta = sin_over_x(theta); - - Scalar scale0 = (Scalar(1)-t)*sin_over_x( ( Scalar(1) - t ) * theta) / sinOverTheta; - Scalar scale1 = t * sin_over_x( ( t * theta) ) / sinOverTheta; - if (d<0) - scale1 = -scale1; - - return Quaternion(scale0 * a.coeffs() + scale1 * b.coeffs()); -} - -template -EIGEN_DONT_INLINE Q slerp_gael(const Q& a, const Q& b, typename Q::Scalar t) -{ - typedef typename Q::Scalar Scalar; - - Scalar d = a.dot(b); - Scalar theta; -// theta = Scalar(2) * atan2((a.coeffs()-b.coeffs()).norm(),(a.coeffs()+b.coeffs()).norm()); -// if (d<0.0) -// theta = M_PI-theta; - - if (d<0.0) - theta = /*M_PI -*/ Scalar(2)*std::asin( (-a.coeffs()-b.coeffs()).norm()/2 ); - else - theta = Scalar(2)*std::asin( (a.coeffs()-b.coeffs()).norm()/2 ); - - - Scalar scale0; - Scalar scale1; - if(theta*theta-Scalar(6)==-Scalar(6)) - { - scale0 = Scalar(1) - t; - scale1 = t; - } - else - { - Scalar sinTheta = std::sin(theta); - scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta; - scale1 = internal::sin( ( t * theta) ) / sinTheta; - if (d<0) - scale1 = -scale1; - } - - return Quaternion(scale0 * a.coeffs() + scale1 * b.coeffs()); -} - -int main() -{ - typedef double RefScalar; - typedef float TestScalar; - - typedef Quaternion Qd; - typedef Quaternion Qf; - - unsigned int g_seed = (unsigned int) time(NULL); - std::cout << g_seed << "\n"; -// g_seed = 1259932496; - srand(g_seed); - - Matrix maxerr(7); - maxerr.setZero(); - - Matrix avgerr(7); - avgerr.setZero(); - - cout << "double=>float=>double nlerp eigen legacy(snap) legacy(nlerp) rightway gael's criteria\n"; - - int rep = 100; - int iters = 40; - for (int w=0; w()); - Qd br(b.cast()); - Qd cr; - - - - cout.precision(8); - cout << std::scientific; - for (int i=0; i(); - c[0] = nlerp(a,b,t); - c[1] = slerp_eigen(a,b,t); - c[2] = slerp_legacy(a,b,t); - c[3] = slerp_legacy_nlerp(a,b,t); - c[4] = slerp_rw(a,b,t); - c[5] = slerp_gael(a,b,t); - - VectorXd err(7); - err[0] = (cr.coeffs()-refc.cast().coeffs()).norm(); -// std::cout << err[0] << " "; - for (int k=0; k<6; ++k) - { - err[k+1] = (c[k].coeffs()-refc.coeffs()).norm(); -// std::cout << err[k+1] << " "; - } - maxerr = maxerr.cwise().max(err); - avgerr += err; -// std::cout << "\n"; - b = cr.cast(); - br = cr; - } -// std::cout << "\n"; - } - avgerr /= RefScalar(rep*iters); - cout << "\n\nAccuracy:\n" - << " max: " << maxerr.transpose() << "\n"; - cout << " avg: " << avgerr.transpose() << "\n"; - - // perf bench - Quaternionf a,b; - a.coeffs().setRandom(); - a.normalize(); - b.coeffs().setRandom(); - b.normalize(); - //b = a; - float s = 0.65; - - #define BENCH(FUNC) {\ - BenchTimer t; \ - for(int k=0; k<2; ++k) {\ - t.start(); \ - for(int i=0; i<1000000; ++i) \ - FUNC(a,b,s); \ - t.stop(); \ - } \ - cout << " " << #FUNC << " => \t " << t.value() << "s\n"; \ - } - - cout << "\nSpeed:\n" << std::fixed; - BENCH(nlerp); - BENCH(slerp_eigen); - BENCH(slerp_legacy); - BENCH(slerp_legacy_nlerp); - BENCH(slerp_rw); - BENCH(slerp_gael); -} - diff --git a/eigen3/bench/quatmul.cpp b/eigen3/bench/quatmul.cpp deleted file mode 100644 --- a/eigen3/bench/quatmul.cpp +++ /dev/null @@ -1,47 +0,0 @@ -#include -#include -#include -#include - -using namespace Eigen; - -template -EIGEN_DONT_INLINE void quatmul_default(const Quat& a, const Quat& b, Quat& c) -{ - c = a * b; -} - -template -EIGEN_DONT_INLINE void quatmul_novec(const Quat& a, const Quat& b, Quat& c) -{ - c = internal::quat_product<0, Quat, Quat, typename Quat::Scalar, Aligned>::run(a,b); -} - -template void bench(const std::string& label) -{ - int tries = 10; - int rep = 1000000; - BenchTimer t; - - Quat a(4, 1, 2, 3); - Quat b(2, 3, 4, 5); - Quat c; - - std::cout.precision(3); - - BENCH(t, tries, rep, quatmul_default(a,b,c)); - std::cout << label << " default " << 1e3*t.best(CPU_TIMER) << "ms \t" << 1e-6*double(rep)/(t.best(CPU_TIMER)) << " M mul/s\n"; - - BENCH(t, tries, rep, quatmul_novec(a,b,c)); - std::cout << label << " novec " << 1e3*t.best(CPU_TIMER) << "ms \t" << 1e-6*double(rep)/(t.best(CPU_TIMER)) << " M mul/s\n"; -} - -int main() -{ - bench("float "); - bench("double"); - - return 0; - -} - diff --git a/eigen3/bench/sparse_cholesky.cpp b/eigen3/bench/sparse_cholesky.cpp deleted file mode 100644 --- a/eigen3/bench/sparse_cholesky.cpp +++ /dev/null @@ -1,216 +0,0 @@ -// #define EIGEN_TAUCS_SUPPORT -// #define EIGEN_CHOLMOD_SUPPORT -#include -#include - -// g++ -DSIZE=10000 -DDENSITY=0.001 sparse_cholesky.cpp -I.. -DDENSEMATRI -O3 -g0 -DNDEBUG -DNBTRIES=1 -I /home/gael/Coding/LinearAlgebra/taucs_full/src/ -I/home/gael/Coding/LinearAlgebra/taucs_full/build/linux/ -L/home/gael/Coding/LinearAlgebra/taucs_full/lib/linux/ -ltaucs /home/gael/Coding/LinearAlgebra/GotoBLAS/libgoto.a -lpthread -I /home/gael/Coding/LinearAlgebra/SuiteSparse/CHOLMOD/Include/ $CHOLLIB -I /home/gael/Coding/LinearAlgebra/SuiteSparse/UFconfig/ /home/gael/Coding/LinearAlgebra/SuiteSparse/CCOLAMD/Lib/libccolamd.a /home/gael/Coding/LinearAlgebra/SuiteSparse/CHOLMOD/Lib/libcholmod.a -lmetis /home/gael/Coding/LinearAlgebra/SuiteSparse/AMD/Lib/libamd.a /home/gael/Coding/LinearAlgebra/SuiteSparse/CAMD/Lib/libcamd.a /home/gael/Coding/LinearAlgebra/SuiteSparse/CCOLAMD/Lib/libccolamd.a /home/gael/Coding/LinearAlgebra/SuiteSparse/COLAMD/Lib/libcolamd.a -llapack && ./a.out - -#define NOGMM -#define NOMTL - -#ifndef SIZE -#define SIZE 10 -#endif - -#ifndef DENSITY -#define DENSITY 0.01 -#endif - -#ifndef REPEAT -#define REPEAT 1 -#endif - -#include "BenchSparseUtil.h" - -#ifndef MINDENSITY -#define MINDENSITY 0.0004 -#endif - -#ifndef NBTRIES -#define NBTRIES 10 -#endif - -#define BENCH(X) \ - timer.reset(); \ - for (int _j=0; _j EigenSparseTriMatrix; -typedef SparseMatrix EigenSparseSelfAdjointMatrix; - -void fillSpdMatrix(float density, int rows, int cols, EigenSparseSelfAdjointMatrix& dst) -{ - dst.startFill(rows*cols*density); - for(int j = 0; j < cols; j++) - { - dst.fill(j,j) = internal::random(10,20); - for(int i = j+1; i < rows; i++) - { - Scalar v = (internal::random(0,1) < density) ? internal::random() : 0; - if (v!=0) - dst.fill(i,j) = v; - } - - } - dst.endFill(); -} - -#include - -template -void doEigen(const char* name, const EigenSparseSelfAdjointMatrix& sm1, int flags = 0) -{ - std::cout << name << "..." << std::flush; - BenchTimer timer; - timer.start(); - SparseLLT chol(sm1, flags); - timer.stop(); - std::cout << ":\t" << timer.value() << endl; - - std::cout << " nnz: " << sm1.nonZeros() << " => " << chol.matrixL().nonZeros() << "\n"; -// std::cout << "sparse\n" << chol.matrixL() << "%\n"; -} - -int main(int argc, char *argv[]) -{ - int rows = SIZE; - int cols = SIZE; - float density = DENSITY; - BenchTimer timer; - - VectorXf b = VectorXf::Random(cols); - VectorXf x = VectorXf::Random(cols); - - bool densedone = false; - - //for (float density = DENSITY; density>=MINDENSITY; density*=0.5) -// float density = 0.5; - { - EigenSparseSelfAdjointMatrix sm1(rows, cols); - std::cout << "Generate sparse matrix (might take a while)...\n"; - fillSpdMatrix(density, rows, cols, sm1); - std::cout << "DONE\n\n"; - - // dense matrices - #ifdef DENSEMATRIX - if (!densedone) - { - densedone = true; - std::cout << "Eigen Dense\t" << density*100 << "%\n"; - DenseMatrix m1(rows,cols); - eiToDense(sm1, m1); - m1 = (m1 + m1.transpose()).eval(); - m1.diagonal() *= 0.5; - -// BENCH(LLT chol(m1);) -// std::cout << "dense:\t" << timer.value() << endl; - - BenchTimer timer; - timer.start(); - LLT chol(m1); - timer.stop(); - std::cout << "dense:\t" << timer.value() << endl; - int count = 0; - for (int j=0; j("Eigen/Sparse", sm1, Eigen::IncompleteFactorization); - - #ifdef EIGEN_CHOLMOD_SUPPORT - doEigen("Eigen/Cholmod", sm1, Eigen::IncompleteFactorization); - #endif - - #ifdef EIGEN_TAUCS_SUPPORT - doEigen("Eigen/Taucs", sm1, Eigen::IncompleteFactorization); - #endif - - #if 0 - // TAUCS - { - taucs_ccs_matrix A = sm1.asTaucsMatrix(); - - //BENCH(taucs_ccs_matrix* chol = taucs_ccs_factor_llt(&A, 0, 0);) -// BENCH(taucs_supernodal_factor_to_ccs(taucs_ccs_factor_llt_ll(&A));) -// std::cout << "taucs:\t" << timer.value() << endl; - - taucs_ccs_matrix* chol = taucs_ccs_factor_llt(&A, 0, 0); - - for (int j=0; jcolptr[j]; icolptr[j+1]; ++i) - std::cout << chol->values.d[i] << " "; - } - } - - // CHOLMOD - #ifdef EIGEN_CHOLMOD_SUPPORT - { - cholmod_common c; - cholmod_start (&c); - cholmod_sparse A; - cholmod_factor *L; - - A = sm1.asCholmodMatrix(); - BenchTimer timer; -// timer.reset(); - timer.start(); - std::vector perm(cols); -// std::vector set(ncols); - for (int i=0; icolptr[j]; icolptr[j+1]; ++i) -// std::cout << chol->values.s[i] << " "; -// } - } - #endif - - #endif - - - - } - - - return 0; -} - diff --git a/eigen3/bench/sparse_dense_product.cpp b/eigen3/bench/sparse_dense_product.cpp deleted file mode 100644 --- a/eigen3/bench/sparse_dense_product.cpp +++ /dev/null @@ -1,187 +0,0 @@ - -//g++ -O3 -g0 -DNDEBUG sparse_product.cpp -I.. -I/home/gael/Coding/LinearAlgebra/mtl4/ -DDENSITY=0.005 -DSIZE=10000 && ./a.out -//g++ -O3 -g0 -DNDEBUG sparse_product.cpp -I.. -I/home/gael/Coding/LinearAlgebra/mtl4/ -DDENSITY=0.05 -DSIZE=2000 && ./a.out -// -DNOGMM -DNOMTL -DCSPARSE -// -I /home/gael/Coding/LinearAlgebra/CSparse/Include/ /home/gael/Coding/LinearAlgebra/CSparse/Lib/libcsparse.a -#ifndef SIZE -#define SIZE 650000 -#endif - -#ifndef DENSITY -#define DENSITY 0.01 -#endif - -#ifndef REPEAT -#define REPEAT 1 -#endif - -#include "BenchSparseUtil.h" - -#ifndef MINDENSITY -#define MINDENSITY 0.0004 -#endif - -#ifndef NBTRIES -#define NBTRIES 10 -#endif - -#define BENCH(X) \ - timer.reset(); \ - for (int _j=0; _j=MINDENSITY; density*=0.5) - { - //fillMatrix(density, rows, cols, sm1); - fillMatrix2(7, rows, cols, sm1); - - // dense matrices - #ifdef DENSEMATRIX - { - std::cout << "Eigen Dense\t" << density*100 << "%\n"; - DenseMatrix m1(rows,cols); - eiToDense(sm1, m1); - - timer.reset(); - timer.start(); - for (int k=0; k m1(sm1); -// std::cout << "Eigen dyn-sparse\t" << m1.nonZeros()/float(m1.rows()*m1.cols())*100 << "%\n"; -// -// BENCH(for (int k=0; k gmmV1(cols), gmmV2(cols); - Map >(&gmmV1[0], cols) = v1; - Map >(&gmmV2[0], cols) = v2; - - BENCH( asm("#myx"); gmm::mult(m1, gmmV1, gmmV2); asm("#myy"); ) - std::cout << " a * v:\t" << timer.value() << endl; - - BENCH( gmm::mult(gmm::transposed(m1), gmmV1, gmmV2); ) - std::cout << " a' * v:\t" << timer.value() << endl; - } - #endif - - #ifndef NOUBLAS - { - std::cout << "ublas sparse\t" << density*100 << "%\n"; - UBlasSparse m1(rows,cols); - eiToUblas(sm1, m1); - - boost::numeric::ublas::vector uv1, uv2; - eiToUblasVec(v1,uv1); - eiToUblasVec(v2,uv2); - -// std::vector gmmV1(cols), gmmV2(cols); -// Map >(&gmmV1[0], cols) = v1; -// Map >(&gmmV2[0], cols) = v2; - - BENCH( uv2 = boost::numeric::ublas::prod(m1, uv1); ) - std::cout << " a * v:\t" << timer.value() << endl; - -// BENCH( boost::ublas::prod(gmm::transposed(m1), gmmV1, gmmV2); ) -// std::cout << " a' * v:\t" << timer.value() << endl; - } - #endif - - // MTL4 - #ifndef NOMTL - { - std::cout << "MTL4\t" << density*100 << "%\n"; - MtlSparse m1(rows,cols); - eiToMtl(sm1, m1); - mtl::dense_vector mtlV1(cols, 1.0); - mtl::dense_vector mtlV2(cols, 1.0); - - timer.reset(); - timer.start(); - for (int k=0; k - -#define NOGMM -#define NOMTL - -#ifndef SIZE -#define SIZE 10 -#endif - -#ifndef DENSITY -#define DENSITY 0.01 -#endif - -#ifndef REPEAT -#define REPEAT 1 -#endif - -#include "BenchSparseUtil.h" - -#ifndef MINDENSITY -#define MINDENSITY 0.0004 -#endif - -#ifndef NBTRIES -#define NBTRIES 10 -#endif - -#define BENCH(X) \ - timer.reset(); \ - for (int _j=0; _j VectorX; - -#include - -template -void doEigen(const char* name, const EigenSparseMatrix& sm1, const VectorX& b, VectorX& x, int flags = 0) -{ - std::cout << name << "..." << std::flush; - BenchTimer timer; timer.start(); - SparseLU lu(sm1, flags); - timer.stop(); - if (lu.succeeded()) - std::cout << ":\t" << timer.value() << endl; - else - { - std::cout << ":\t FAILED" << endl; - return; - } - - bool ok; - timer.reset(); timer.start(); - ok = lu.solve(b,&x); - timer.stop(); - if (ok) - std::cout << " solve:\t" << timer.value() << endl; - else - std::cout << " solve:\t" << " FAILED" << endl; - - //std::cout << x.transpose() << "\n"; -} - -int main(int argc, char *argv[]) -{ - int rows = SIZE; - int cols = SIZE; - float density = DENSITY; - BenchTimer timer; - - VectorX b = VectorX::Random(cols); - VectorX x = VectorX::Random(cols); - - bool densedone = false; - - //for (float density = DENSITY; density>=MINDENSITY; density*=0.5) -// float density = 0.5; - { - EigenSparseMatrix sm1(rows, cols); - fillMatrix(density, rows, cols, sm1); - - // dense matrices - #ifdef DENSEMATRIX - if (!densedone) - { - densedone = true; - std::cout << "Eigen Dense\t" << density*100 << "%\n"; - DenseMatrix m1(rows,cols); - eiToDense(sm1, m1); - - BenchTimer timer; - timer.start(); - FullPivLU lu(m1); - timer.stop(); - std::cout << "Eigen/dense:\t" << timer.value() << endl; - - timer.reset(); - timer.start(); - lu.solve(b,&x); - timer.stop(); - std::cout << " solve:\t" << timer.value() << endl; -// std::cout << b.transpose() << "\n"; -// std::cout << x.transpose() << "\n"; - } - #endif - - #ifdef EIGEN_UMFPACK_SUPPORT - x.setZero(); - doEigen("Eigen/UmfPack (auto)", sm1, b, x, 0); - #endif - - #ifdef EIGEN_SUPERLU_SUPPORT - x.setZero(); - doEigen("Eigen/SuperLU (nat)", sm1, b, x, Eigen::NaturalOrdering); -// doEigen("Eigen/SuperLU (MD AT+A)", sm1, b, x, Eigen::MinimumDegree_AT_PLUS_A); -// doEigen("Eigen/SuperLU (MD ATA)", sm1, b, x, Eigen::MinimumDegree_ATA); - doEigen("Eigen/SuperLU (COLAMD)", sm1, b, x, Eigen::ColApproxMinimumDegree); - #endif - - } - - return 0; -} - diff --git a/eigen3/bench/sparse_product.cpp b/eigen3/bench/sparse_product.cpp deleted file mode 100644 --- a/eigen3/bench/sparse_product.cpp +++ /dev/null @@ -1,323 +0,0 @@ - -//g++ -O3 -g0 -DNDEBUG sparse_product.cpp -I.. -I/home/gael/Coding/LinearAlgebra/mtl4/ -DDENSITY=0.005 -DSIZE=10000 && ./a.out -//g++ -O3 -g0 -DNDEBUG sparse_product.cpp -I.. -I/home/gael/Coding/LinearAlgebra/mtl4/ -DDENSITY=0.05 -DSIZE=2000 && ./a.out -// -DNOGMM -DNOMTL -DCSPARSE -// -I /home/gael/Coding/LinearAlgebra/CSparse/Include/ /home/gael/Coding/LinearAlgebra/CSparse/Lib/libcsparse.a - -#include - -#ifndef SIZE -#define SIZE 1000000 -#endif - -#ifndef NNZPERCOL -#define NNZPERCOL 6 -#endif - -#ifndef REPEAT -#define REPEAT 1 -#endif - -#include -#include "BenchTimer.h" -#include "BenchUtil.h" -#include "BenchSparseUtil.h" - -#ifndef NBTRIES -#define NBTRIES 1 -#endif - -#define BENCH(X) \ - timer.reset(); \ - for (int _j=0; _j -// void mkl_multiply(const Lhs& lhs, const Rhs& rhs, Res& res) -// { -// char n = 'N'; -// float alpha = 1; -// char matdescra[6]; -// matdescra[0] = 'G'; -// matdescra[1] = 0; -// matdescra[2] = 0; -// matdescra[3] = 'C'; -// mkl_scscmm(&n, lhs.rows(), rhs.cols(), lhs.cols(), &alpha, matdescra, -// lhs._valuePtr(), lhs._innerIndexPtr(), lhs.outerIndexPtr(), -// pntre, b, &ldb, &beta, c, &ldc); -// // mkl_somatcopy('C', 'T', lhs.rows(), lhs.cols(), 1, -// // lhs._valuePtr(), lhs.rows(), DST, dst_stride); -// } -// -// #endif - - -#ifdef CSPARSE -cs* cs_sorted_multiply(const cs* a, const cs* b) -{ -// return cs_multiply(a,b); - - cs* A = cs_transpose(a, 1); - cs* B = cs_transpose(b, 1); - cs* D = cs_multiply(B,A); /* D = B'*A' */ - cs_spfree (A) ; - cs_spfree (B) ; - cs_dropzeros (D) ; /* drop zeros from D */ - cs* C = cs_transpose (D, 1) ; /* C = D', so that C is sorted */ - cs_spfree (D) ; - return C; - -// cs* A = cs_transpose(a, 1); -// cs* C = cs_transpose(A, 1); -// return C; -} - -cs* cs_sorted_multiply2(const cs* a, const cs* b) -{ - cs* D = cs_multiply(a,b); - cs* E = cs_transpose(D,1); - cs_spfree(D); - cs* C = cs_transpose(E,1); - cs_spfree(E); - return C; -} -#endif - -void bench_sort(); - -int main(int argc, char *argv[]) -{ -// bench_sort(); - - int rows = SIZE; - int cols = SIZE; - float density = DENSITY; - - EigenSparseMatrix sm1(rows,cols), sm2(rows,cols), sm3(rows,cols), sm4(rows,cols); - - BenchTimer timer; - for (int nnzPerCol = NNZPERCOL; nnzPerCol>1; nnzPerCol/=1.1) - { - sm1.setZero(); - sm2.setZero(); - fillMatrix2(nnzPerCol, rows, cols, sm1); - fillMatrix2(nnzPerCol, rows, cols, sm2); -// std::cerr << "filling OK\n"; - - // dense matrices - #ifdef DENSEMATRIX - { - std::cout << "Eigen Dense\t" << nnzPerCol << "%\n"; - DenseMatrix m1(rows,cols), m2(rows,cols), m3(rows,cols); - eiToDense(sm1, m1); - eiToDense(sm2, m2); - - timer.reset(); - timer.start(); - for (int k=0; k m1(sm1), m2(sm2), m3(sm3); - std::cout << "Eigen dyn-sparse\t" << m1.nonZeros()/(float(m1.rows())*float(m1.cols()))*100 << "% * " - << m2.nonZeros()/(float(m2.rows())*float(m2.cols()))*100 << "%\n"; - -// timer.reset(); -// timer.start(); - BENCH(for (int k=0; k -#include -#include -#include - -#ifndef SIZE -#define SIZE 10000 -#endif - -#ifndef DENSITY -#define DENSITY 0.01 -#endif - -#ifndef REPEAT -#define REPEAT 1 -#endif - -#include "BenchSparseUtil.h" - -#ifndef MINDENSITY -#define MINDENSITY 0.0004 -#endif - -#ifndef NBTRIES -#define NBTRIES 10 -#endif - -#define BENCH(X) \ - timer.reset(); \ - for (int _j=0; _j -void dostuff(const char* name, EigenSparseMatrix& sm1) -{ - int rows = sm1.rows(); - int cols = sm1.cols(); - sm1.setZero(); - BenchTimer t; - SetterType* set1 = new SetterType(sm1); - t.reset(); t.start(); - for (int k=0; k(0,rows-1),internal::random(0,cols-1)) += 1; - t.stop(); - std::cout << "std::map => \t" << t.value()-rtime - << " nnz=" << set1->nonZeros() << std::flush; - - // getchar(); - - t.reset(); t.start(); delete set1; t.stop(); - std::cout << " back: \t" << t.value() << "\n"; -} - -int main(int argc, char *argv[]) -{ - int rows = SIZE; - int cols = SIZE; - float density = DENSITY; - - EigenSparseMatrix sm1(rows,cols), sm2(rows,cols); - - - nentries = rows*cols*density; - std::cout << "n = " << nentries << "\n"; - int dummy; - BenchTimer t; - - t.reset(); t.start(); - for (int k=0; k(0,rows-1) + internal::random(0,cols-1); - t.stop(); - rtime = t.value(); - std::cout << "rtime = " << rtime << " (" << dummy << ")\n\n"; - const int Bits = 6; - for (;;) - { - dostuff >("std::map ", sm1); - dostuff >("gnu::hash_map", sm1); - dostuff >("google::dense", sm1); - dostuff >("google::sparse", sm1); - -// { -// RandomSetter set1(sm1); -// t.reset(); t.start(); -// for (int k=0; k(0,rows-1),internal::random(0,cols-1)) += 1; -// t.stop(); -// std::cout << "gnu::hash_map => \t" << t.value()-rtime -// << " nnz=" << set1.nonZeros() << "\n";getchar(); -// } -// { -// RandomSetter set1(sm1); -// t.reset(); t.start(); -// for (int k=0; k(0,rows-1),internal::random(0,cols-1)) += 1; -// t.stop(); -// std::cout << "google::dense => \t" << t.value()-rtime -// << " nnz=" << set1.nonZeros() << "\n";getchar(); -// } -// { -// RandomSetter set1(sm1); -// t.reset(); t.start(); -// for (int k=0; k(0,rows-1),internal::random(0,cols-1)) += 1; -// t.stop(); -// std::cout << "google::sparse => \t" << t.value()-rtime -// << " nnz=" << set1.nonZeros() << "\n";getchar(); -// } - std::cout << "\n\n"; - } - - return 0; -} - diff --git a/eigen3/bench/sparse_setter.cpp b/eigen3/bench/sparse_setter.cpp deleted file mode 100644 --- a/eigen3/bench/sparse_setter.cpp +++ /dev/null @@ -1,485 +0,0 @@ - -//g++ -O3 -g0 -DNDEBUG sparse_product.cpp -I.. -I/home/gael/Coding/LinearAlgebra/mtl4/ -DDENSITY=0.005 -DSIZE=10000 && ./a.out -//g++ -O3 -g0 -DNDEBUG sparse_product.cpp -I.. -I/home/gael/Coding/LinearAlgebra/mtl4/ -DDENSITY=0.05 -DSIZE=2000 && ./a.out -// -DNOGMM -DNOMTL -DCSPARSE -// -I /home/gael/Coding/LinearAlgebra/CSparse/Include/ /home/gael/Coding/LinearAlgebra/CSparse/Lib/libcsparse.a -#ifndef SIZE -#define SIZE 100000 -#endif - -#ifndef NBPERROW -#define NBPERROW 24 -#endif - -#ifndef REPEAT -#define REPEAT 2 -#endif - -#ifndef NBTRIES -#define NBTRIES 2 -#endif - -#ifndef KK -#define KK 10 -#endif - -#ifndef NOGOOGLE -#define EIGEN_GOOGLEHASH_SUPPORT -#include -#endif - -#include "BenchSparseUtil.h" - -#define CHECK_MEM -// #define CHECK_MEM std/**/::cout << "check mem\n"; getchar(); - -#define BENCH(X) \ - timer.reset(); \ - for (int _j=0; _j Coordinates; -typedef std::vector Values; - -EIGEN_DONT_INLINE Scalar* setinnerrand_eigen(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_eigen_dynamic(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_eigen_compact(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_eigen_sumeq(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_eigen_gnu_hash(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_eigen_google_dense(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_eigen_google_sparse(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_scipy(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_ublas_mapped(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_ublas_coord(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_ublas_compressed(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_ublas_genvec(const Coordinates& coords, const Values& vals); -EIGEN_DONT_INLINE Scalar* setrand_mtl(const Coordinates& coords, const Values& vals); - -int main(int argc, char *argv[]) -{ - int rows = SIZE; - int cols = SIZE; - bool fullyrand = true; - - BenchTimer timer; - Coordinates coords; - Values values; - if(fullyrand) - { - Coordinates pool; - pool.reserve(cols*NBPERROW); - std::cerr << "fill pool" << "\n"; - for (int i=0; i stencil(SIZE,SIZE); - Vector2i ij(internal::random(0,rows-1),internal::random(0,cols-1)); -// if(stencil.coeffRef(ij.x(), ij.y())==0) - { -// stencil.coeffRef(ij.x(), ij.y()) = 1; - pool.push_back(ij); - - } - ++i; - } - std::cerr << "pool ok" << "\n"; - int n = cols*NBPERROW*KK; - coords.reserve(n); - values.reserve(n); - for (int i=0; i(0,pool.size()); - coords.push_back(pool[i]); - values.push_back(internal::random()); - } - } - else - { - for (int j=0; j(0,rows-1),j)); - values.push_back(internal::random()); - } - } - std::cout << "nnz = " << coords.size() << "\n"; - CHECK_MEM - - // dense matrices - #ifdef DENSEMATRIX - { - BENCH(setrand_eigen_dense(coords,values);) - std::cout << "Eigen Dense\t" << timer.value() << "\n"; - } - #endif - - // eigen sparse matrices -// if (!fullyrand) -// { -// BENCH(setinnerrand_eigen(coords,values);) -// std::cout << "Eigen fillrand\t" << timer.value() << "\n"; -// } - { - BENCH(setrand_eigen_dynamic(coords,values);) - std::cout << "Eigen dynamic\t" << timer.value() << "\n"; - } -// { -// BENCH(setrand_eigen_compact(coords,values);) -// std::cout << "Eigen compact\t" << timer.value() << "\n"; -// } - { - BENCH(setrand_eigen_sumeq(coords,values);) - std::cout << "Eigen sumeq\t" << timer.value() << "\n"; - } - { -// BENCH(setrand_eigen_gnu_hash(coords,values);) -// std::cout << "Eigen std::map\t" << timer.value() << "\n"; - } - { - BENCH(setrand_scipy(coords,values);) - std::cout << "scipy\t" << timer.value() << "\n"; - } - #ifndef NOGOOGLE - { - BENCH(setrand_eigen_google_dense(coords,values);) - std::cout << "Eigen google dense\t" << timer.value() << "\n"; - } - { - BENCH(setrand_eigen_google_sparse(coords,values);) - std::cout << "Eigen google sparse\t" << timer.value() << "\n"; - } - #endif - - #ifndef NOUBLAS - { -// BENCH(setrand_ublas_mapped(coords,values);) -// std::cout << "ublas mapped\t" << timer.value() << "\n"; - } - { - BENCH(setrand_ublas_genvec(coords,values);) - std::cout << "ublas vecofvec\t" << timer.value() << "\n"; - } - /*{ - timer.reset(); - timer.start(); - for (int k=0; k mat(SIZE,SIZE); - //mat.startFill(2000000/*coords.size()*/); - for (int i=0; i mat(SIZE,SIZE); - mat.reserve(coords.size()/10); - for (int i=0; i mat(SIZE,SIZE); - for (int j=0; j aux(SIZE,SIZE); - mat.reserve(n); - for (int i=j*n; i<(j+1)*n; ++i) - { - aux.insert(coords[i].x(), coords[i].y()) += vals[i]; - } - aux.finalize(); - mat += aux; - } - return &mat.coeffRef(coords[0].x(), coords[0].y()); -} - -EIGEN_DONT_INLINE Scalar* setrand_eigen_compact(const Coordinates& coords, const Values& vals) -{ - using namespace Eigen; - DynamicSparseMatrix setter(SIZE,SIZE); - setter.reserve(coords.size()/10); - for (int i=0; i mat = setter; - CHECK_MEM; - return &mat.coeffRef(coords[0].x(), coords[0].y()); -} - -EIGEN_DONT_INLINE Scalar* setrand_eigen_gnu_hash(const Coordinates& coords, const Values& vals) -{ - using namespace Eigen; - SparseMatrix mat(SIZE,SIZE); - { - RandomSetter, StdMapTraits > setter(mat); - for (int i=0; i mat(SIZE,SIZE); - { - RandomSetter, GoogleDenseHashMapTraits> setter(mat); - for (int i=0; i mat(SIZE,SIZE); - { - RandomSetter, GoogleSparseHashMapTraits> setter(mat); - for (int i=0; i -void coo_tocsr(const int n_row, - const int n_col, - const int nnz, - const Coordinates Aij, - const Values Ax, - int Bp[], - int Bj[], - T Bx[]) -{ - //compute number of non-zero entries per row of A coo_tocsr - std::fill(Bp, Bp + n_row, 0); - - for (int n = 0; n < nnz; n++){ - Bp[Aij[n].x()]++; - } - - //cumsum the nnz per row to get Bp[] - for(int i = 0, cumsum = 0; i < n_row; i++){ - int temp = Bp[i]; - Bp[i] = cumsum; - cumsum += temp; - } - Bp[n_row] = nnz; - - //write Aj,Ax into Bj,Bx - for(int n = 0; n < nnz; n++){ - int row = Aij[n].x(); - int dest = Bp[row]; - - Bj[dest] = Aij[n].y(); - Bx[dest] = Ax[n]; - - Bp[row]++; - } - - for(int i = 0, last = 0; i <= n_row; i++){ - int temp = Bp[i]; - Bp[i] = last; - last = temp; - } - - //now Bp,Bj,Bx form a CSR representation (with possible duplicates) -} - -template< class T1, class T2 > -bool kv_pair_less(const std::pair& x, const std::pair& y){ - return x.first < y.first; -} - - -template -void csr_sort_indices(const I n_row, - const I Ap[], - I Aj[], - T Ax[]) -{ - std::vector< std::pair > temp; - - for(I i = 0; i < n_row; i++){ - I row_start = Ap[i]; - I row_end = Ap[i+1]; - - temp.clear(); - - for(I jj = row_start; jj < row_end; jj++){ - temp.push_back(std::make_pair(Aj[jj],Ax[jj])); - } - - std::sort(temp.begin(),temp.end(),kv_pair_less); - - for(I jj = row_start, n = 0; jj < row_end; jj++, n++){ - Aj[jj] = temp[n].first; - Ax[jj] = temp[n].second; - } - } -} - -template -void csr_sum_duplicates(const I n_row, - const I n_col, - I Ap[], - I Aj[], - T Ax[]) -{ - I nnz = 0; - I row_end = 0; - for(I i = 0; i < n_row; i++){ - I jj = row_end; - row_end = Ap[i+1]; - while( jj < row_end ){ - I j = Aj[jj]; - T x = Ax[jj]; - jj++; - while( jj < row_end && Aj[jj] == j ){ - x += Ax[jj]; - jj++; - } - Aj[nnz] = j; - Ax[nnz] = x; - nnz++; - } - Ap[i+1] = nnz; - } -} - -EIGEN_DONT_INLINE Scalar* setrand_scipy(const Coordinates& coords, const Values& vals) -{ - using namespace Eigen; - SparseMatrix mat(SIZE,SIZE); - mat.resizeNonZeros(coords.size()); -// std::cerr << "setrand_scipy...\n"; - coo_tocsr(SIZE,SIZE, coords.size(), coords, vals, mat._outerIndexPtr(), mat._innerIndexPtr(), mat._valuePtr()); -// std::cerr << "coo_tocsr ok\n"; - - csr_sort_indices(SIZE, mat._outerIndexPtr(), mat._innerIndexPtr(), mat._valuePtr()); - - csr_sum_duplicates(SIZE, SIZE, mat._outerIndexPtr(), mat._innerIndexPtr(), mat._valuePtr()); - - mat.resizeNonZeros(mat._outerIndexPtr()[SIZE]); - - return &mat.coeffRef(coords[0].x(), coords[0].y()); -} - - -#ifndef NOUBLAS -EIGEN_DONT_INLINE Scalar* setrand_ublas_mapped(const Coordinates& coords, const Values& vals) -{ - using namespace boost; - using namespace boost::numeric; - using namespace boost::numeric::ublas; - mapped_matrix aux(SIZE,SIZE); - for (int i=0; i mat(aux); - return 0;// &mat(coords[0].x(), coords[0].y()); -} -/*EIGEN_DONT_INLINE Scalar* setrand_ublas_coord(const Coordinates& coords, const Values& vals) -{ - using namespace boost; - using namespace boost::numeric; - using namespace boost::numeric::ublas; - coordinate_matrix aux(SIZE,SIZE); - for (int i=0; i mat(aux); - return 0;//&mat(coords[0].x(), coords[0].y()); -} -EIGEN_DONT_INLINE Scalar* setrand_ublas_compressed(const Coordinates& coords, const Values& vals) -{ - using namespace boost; - using namespace boost::numeric; - using namespace boost::numeric::ublas; - compressed_matrix mat(SIZE,SIZE); - for (int i=0; i > foo; - generalized_vector_of_vector > > aux(SIZE,SIZE); - for (int i=0; i mat(aux); - return 0;//&mat(coords[0].x(), coords[0].y()); -} -#endif - -#ifndef NOMTL -EIGEN_DONT_INLINE void setrand_mtl(const Coordinates& coords, const Values& vals); -#endif - diff --git a/eigen3/bench/sparse_transpose.cpp b/eigen3/bench/sparse_transpose.cpp deleted file mode 100644 --- a/eigen3/bench/sparse_transpose.cpp +++ /dev/null @@ -1,104 +0,0 @@ - -//g++ -O3 -g0 -DNDEBUG sparse_transpose.cpp -I.. -I/home/gael/Coding/LinearAlgebra/mtl4/ -DDENSITY=0.005 -DSIZE=10000 && ./a.out -// -DNOGMM -DNOMTL -// -DCSPARSE -I /home/gael/Coding/LinearAlgebra/CSparse/Include/ /home/gael/Coding/LinearAlgebra/CSparse/Lib/libcsparse.a - -#ifndef SIZE -#define SIZE 10000 -#endif - -#ifndef DENSITY -#define DENSITY 0.01 -#endif - -#ifndef REPEAT -#define REPEAT 1 -#endif - -#include "BenchSparseUtil.h" - -#ifndef MINDENSITY -#define MINDENSITY 0.0004 -#endif - -#ifndef NBTRIES -#define NBTRIES 10 -#endif - -#define BENCH(X) \ - timer.reset(); \ - for (int _j=0; _j=MINDENSITY; density*=0.5) - { - fillMatrix(density, rows, cols, sm1); - - // dense matrices - #ifdef DENSEMATRIX - { - DenseMatrix m1(rows,cols), m3(rows,cols); - eiToDense(sm1, m1); - BENCH(for (int k=0; k EigenSparseTriMatrix; -typedef SparseMatrix EigenSparseTriMatrixRow; - -void fillMatrix(float density, int rows, int cols, EigenSparseTriMatrix& dst) -{ - dst.startFill(rows*cols*density); - for(int j = 0; j < cols; j++) - { - for(int i = 0; i < j; i++) - { - Scalar v = (internal::random(0,1) < density) ? internal::random() : 0; - if (v!=0) - dst.fill(i,j) = v; - } - dst.fill(j,j) = internal::random(); - } - dst.endFill(); -} - -int main(int argc, char *argv[]) -{ - int rows = SIZE; - int cols = SIZE; - float density = DENSITY; - BenchTimer timer; - #if 1 - EigenSparseTriMatrix sm1(rows,cols); - typedef Matrix DenseVector; - DenseVector b = DenseVector::Random(cols); - DenseVector x = DenseVector::Random(cols); - - bool densedone = false; - - for (float density = DENSITY; density>=MINDENSITY; density*=0.5) - { - EigenSparseTriMatrix sm1(rows, cols); - fillMatrix(density, rows, cols, sm1); - - // dense matrices - #ifdef DENSEMATRIX - if (!densedone) - { - densedone = true; - std::cout << "Eigen Dense\t" << density*100 << "%\n"; - DenseMatrix m1(rows,cols); - Matrix m2(rows,cols); - eiToDense(sm1, m1); - m2 = m1; - - BENCH(x = m1.marked().solveTriangular(b);) - std::cout << " colmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << x.transpose() << "\n"; - - BENCH(x = m2.marked().solveTriangular(b);) - std::cout << " rowmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << x.transpose() << "\n"; - } - #endif - - // eigen sparse matrices - { - std::cout << "Eigen sparse\t" << density*100 << "%\n"; - EigenSparseTriMatrixRow sm2 = sm1; - - BENCH(x = sm1.solveTriangular(b);) - std::cout << " colmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << x.transpose() << "\n"; - - BENCH(x = sm2.solveTriangular(b);) - std::cout << " rowmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << x.transpose() << "\n"; - -// x = b; -// BENCH(sm1.inverseProductInPlace(x);) -// std::cout << " colmajor^-1 * b:\t" << timer.value() << " (inplace)" << endl; -// std::cerr << x.transpose() << "\n"; -// -// x = b; -// BENCH(sm2.inverseProductInPlace(x);) -// std::cout << " rowmajor^-1 * b:\t" << timer.value() << " (inplace)" << endl; -// std::cerr << x.transpose() << "\n"; - } - - - - // CSparse - #ifdef CSPARSE - { - std::cout << "CSparse \t" << density*100 << "%\n"; - cs *m1; - eiToCSparse(sm1, m1); - - BENCH(x = b; if (!cs_lsolve (m1, x.data())){std::cerr << "cs_lsolve failed\n"; break;}; ) - std::cout << " colmajor^-1 * b:\t" << timer.value() << endl; - } - #endif - - // GMM++ - #ifndef NOGMM - { - std::cout << "GMM++ sparse\t" << density*100 << "%\n"; - GmmSparse m1(rows,cols); - gmm::csr_matrix m2; - eiToGmm(sm1, m1); - gmm::copy(m1,m2); - std::vector gmmX(cols), gmmB(cols); - Map >(&gmmX[0], cols) = x; - Map >(&gmmB[0], cols) = b; - - gmmX = gmmB; - BENCH(gmm::upper_tri_solve(m1, gmmX, false);) - std::cout << " colmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << Map >(&gmmX[0], cols).transpose() << "\n"; - - gmmX = gmmB; - BENCH(gmm::upper_tri_solve(m2, gmmX, false);) - timer.stop(); - std::cout << " rowmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << Map >(&gmmX[0], cols).transpose() << "\n"; - } - #endif - - // MTL4 - #ifndef NOMTL - { - std::cout << "MTL4\t" << density*100 << "%\n"; - MtlSparse m1(rows,cols); - MtlSparseRowMajor m2(rows,cols); - eiToMtl(sm1, m1); - m2 = m1; - mtl::dense_vector x(rows, 1.0); - mtl::dense_vector b(rows, 1.0); - - BENCH(x = mtl::upper_trisolve(m1,b);) - std::cout << " colmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << x << "\n"; - - BENCH(x = mtl::upper_trisolve(m2,b);) - std::cout << " rowmajor^-1 * b:\t" << timer.value() << endl; -// std::cerr << x << "\n"; - } - #endif - - - std::cout << "\n\n"; - } - #endif - - #if 0 - // bench small matrices (in-place versus return bye value) - { - timer.reset(); - for (int _j=0; _j<10; ++_j) { - Matrix4f m = Matrix4f::Random(); - Vector4f b = Vector4f::Random(); - Vector4f x = Vector4f::Random(); - timer.start(); - for (int _k=0; _k<1000000; ++_k) { - b = m.inverseProduct(b); - } - timer.stop(); - } - std::cout << "4x4 :\t" << timer.value() << endl; - } - - { - timer.reset(); - for (int _j=0; _j<10; ++_j) { - Matrix4f m = Matrix4f::Random(); - Vector4f b = Vector4f::Random(); - Vector4f x = Vector4f::Random(); - timer.start(); - for (int _k=0; _k<1000000; ++_k) { - m.inverseProductInPlace(x); - } - timer.stop(); - } - std::cout << "4x4 IP :\t" << timer.value() << endl; - } - #endif - - return 0; -} - diff --git a/eigen3/bench/spbench/CMakeLists.txt b/eigen3/bench/spbench/CMakeLists.txt deleted file mode 100644 --- a/eigen3/bench/spbench/CMakeLists.txt +++ /dev/null @@ -1,78 +0,0 @@ - - -set(BLAS_FOUND TRUE) -set(LAPACK_FOUND TRUE) -set(BLAS_LIBRARIES eigen_blas_static) -set(LAPACK_LIBRARIES eigen_lapack_static) - -set(SPARSE_LIBS "") - -# find_library(PARDISO_LIBRARIES pardiso412-GNU450-X86-64) -# if(PARDISO_LIBRARIES) -# add_definitions("-DEIGEN_PARDISO_SUPPORT") -# set(SPARSE_LIBS ${SPARSE_LIBS} ${PARDISO_LIBRARIES}) -# endif(PARDISO_LIBRARIES) - -find_package(Cholmod) -if(CHOLMOD_FOUND AND BLAS_FOUND AND LAPACK_FOUND) - add_definitions("-DEIGEN_CHOLMOD_SUPPORT") - include_directories(${CHOLMOD_INCLUDES}) - set(SPARSE_LIBS ${SPARSE_LIBS} ${CHOLMOD_LIBRARIES} ${BLAS_LIBRARIES} ${LAPACK_LIBRARIES}) - set(CHOLMOD_ALL_LIBS ${CHOLMOD_LIBRARIES} ${BLAS_LIBRARIES} ${LAPACK_LIBRARIES}) -endif() - -find_package(Umfpack) -if(UMFPACK_FOUND AND BLAS_FOUND) - add_definitions("-DEIGEN_UMFPACK_SUPPORT") - include_directories(${UMFPACK_INCLUDES}) - set(SPARSE_LIBS ${SPARSE_LIBS} ${UMFPACK_LIBRARIES} ${BLAS_LIBRARIES}) - set(UMFPACK_ALL_LIBS ${UMFPACK_LIBRARIES} ${BLAS_LIBRARIES}) -endif() - -find_package(SuperLU) -if(SUPERLU_FOUND AND BLAS_FOUND) - add_definitions("-DEIGEN_SUPERLU_SUPPORT") - include_directories(${SUPERLU_INCLUDES}) - set(SPARSE_LIBS ${SPARSE_LIBS} ${SUPERLU_LIBRARIES} ${BLAS_LIBRARIES}) - set(SUPERLU_ALL_LIBS ${SUPERLU_LIBRARIES} ${BLAS_LIBRARIES}) -endif() - - -find_package(Pastix) -find_package(Scotch) -find_package(Metis) -if(PASTIX_FOUND AND BLAS_FOUND) - add_definitions("-DEIGEN_PASTIX_SUPPORT") - include_directories(${PASTIX_INCLUDES}) - if(SCOTCH_FOUND) - include_directories(${SCOTCH_INCLUDES}) - set(PASTIX_LIBRARIES ${PASTIX_LIBRARIES} ${SCOTCH_LIBRARIES}) - elseif(METIS_FOUND) - include_directories(${METIS_INCLUDES}) - set(PASTIX_LIBRARIES ${PASTIX_LIBRARIES} ${METIS_LIBRARIES}) - endif(SCOTCH_FOUND) - set(SPARSE_LIBS ${SPARSE_LIBS} ${PASTIX_LIBRARIES} ${ORDERING_LIBRARIES} ${BLAS_LIBRARIES}) - set(PASTIX_ALL_LIBS ${PASTIX_LIBRARIES} ${BLAS_LIBRARIES}) -endif(PASTIX_FOUND AND BLAS_FOUND) - -if(METIS_FOUND) - include_directories(${METIS_INCLUDES}) - set (SPARSE_LIBS ${SPARSE_LIBS} ${METIS_LIBRARIES}) - add_definitions("-DEIGEN_METIS_SUPPORT") -endif(METIS_FOUND) - -find_library(RT_LIBRARY rt) -if(RT_LIBRARY) - set(SPARSE_LIBS ${SPARSE_LIBS} ${RT_LIBRARY}) -endif(RT_LIBRARY) - -add_executable(spbenchsolver spbenchsolver.cpp) -target_link_libraries (spbenchsolver ${SPARSE_LIBS}) - -add_executable(spsolver sp_solver.cpp) -target_link_libraries (spsolver ${SPARSE_LIBS}) - - -add_executable(test_sparseLU test_sparseLU.cpp) -target_link_libraries (test_sparseLU ${SPARSE_LIBS}) - diff --git a/eigen3/bench/spbench/sp_solver.cpp b/eigen3/bench/spbench/sp_solver.cpp deleted file mode 100644 --- a/eigen3/bench/spbench/sp_solver.cpp +++ /dev/null @@ -1,125 +0,0 @@ -// Small bench routine for Eigen available in Eigen -// (C) Desire NUENTSA WAKAM, INRIA - -#include -#include -#include -#include -#include -#include -#include -#include -//#include -#include -// #include -#include -#include -using namespace std; -using namespace Eigen; - -int main(int argc, char **args) -{ - SparseMatrix A; - typedef SparseMatrix::Index Index; - typedef Matrix DenseMatrix; - typedef Matrix DenseRhs; - VectorXd b, x, tmp; - BenchTimer timer,totaltime; - //SparseLU > solver; -// SuperLU > solver; - ConjugateGradient, Lower,IncompleteCholesky > solver; - ifstream matrix_file; - string line; - int n; - // Set parameters -// solver.iparm(IPARM_THREAD_NBR) = 4; - /* Fill the matrix with sparse matrix stored in Matrix-Market coordinate column-oriented format */ - if (argc < 2) assert(false && "please, give the matrix market file "); - - timer.start(); - totaltime.start(); - loadMarket(A, args[1]); - cout << "End charging matrix " << endl; - bool iscomplex=false, isvector=false; - int sym; - getMarketHeader(args[1], sym, iscomplex, isvector); - if (iscomplex) { cout<< " Not for complex matrices \n"; return -1; } - if (isvector) { cout << "The provided file is not a matrix file\n"; return -1;} - if (sym != 0) { // symmetric matrices, only the lower part is stored - SparseMatrix temp; - temp = A; - A = temp.selfadjointView(); - } - timer.stop(); - - n = A.cols(); - // ====== TESTS FOR SPARSE TUTORIAL ====== -// cout<< "OuterSize " << A.outerSize() << " inner " << A.innerSize() << endl; -// SparseMatrix mat1(A); -// SparseMatrix mat2; -// cout << " norm of A " << mat1.norm() << endl; ; -// PermutationMatrix perm(n); -// perm.resize(n,1); -// perm.indices().setLinSpaced(n, 0, n-1); -// mat2 = perm * mat1; -// mat.subrows(); -// mat2.resize(n,n); -// mat2.reserve(10); -// mat2.setConstant(); -// std::cout<< "NORM " << mat1.squaredNorm()<< endl; - - cout<< "Time to load the matrix " << timer.value() < 2) - loadMarketVector(b, args[2]); - else - { - b.resize(n); - tmp.resize(n); -// tmp.setRandom(); - for (int i = 0; i < n; i++) tmp(i) = i; - b = A * tmp ; - } -// Scaling > scal; -// scal.computeRef(A); -// b = scal.LeftScaling().cwiseProduct(b); - - /* Compute the factorization */ - cout<< "Starting the factorization "<< endl; - timer.reset(); - timer.start(); - cout<< "Size of Input Matrix "<< b.size()<<"\n\n"; - cout<< "Rows and columns "<< A.rows() <<" " < - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/eigen3/bench/spbench/spbenchsolver.cpp b/eigen3/bench/spbench/spbenchsolver.cpp deleted file mode 100644 --- a/eigen3/bench/spbench/spbenchsolver.cpp +++ /dev/null @@ -1,87 +0,0 @@ -#include - -void bench_printhelp() -{ - cout<< " \nbenchsolver : performs a benchmark of all the solvers available in Eigen \n\n"; - cout<< " MATRIX FOLDER : \n"; - cout<< " The matrices for the benchmark should be collected in a folder specified with an environment variable EIGEN_MATRIXDIR \n"; - cout<< " The matrices are stored using the matrix market coordinate format \n"; - cout<< " The matrix and associated right-hand side (rhs) files are named respectively \n"; - cout<< " as MatrixName.mtx and MatrixName_b.mtx. If the rhs does not exist, a random one is generated. \n"; - cout<< " If a matrix is SPD, the matrix should be named as MatrixName_SPD.mtx \n"; - cout<< " If a true solution exists, it should be named as MatrixName_x.mtx; \n" ; - cout<< " it will be used to compute the norm of the error relative to the computed solutions\n\n"; - cout<< " OPTIONS : \n"; - cout<< " -h or --help \n print this help and return\n\n"; - cout<< " -d matrixdir \n Use matrixdir as the matrix folder instead of the one specified in the environment variable EIGEN_MATRIXDIR\n\n"; - cout<< " -o outputfile.xml \n Output the statistics to a xml file \n\n"; - cout<< " --eps Sets the relative tolerance for iterative solvers (default 1e-08) \n\n"; - cout<< " --maxits Sets the maximum number of iterations (default 1000) \n\n"; - -} -int main(int argc, char ** args) -{ - - bool help = ( get_options(argc, args, "-h") || get_options(argc, args, "--help") ); - if(help) { - bench_printhelp(); - return 0; - } - - // Get the location of the test matrices - string matrix_dir; - if (!get_options(argc, args, "-d", &matrix_dir)) - { - if(getenv("EIGEN_MATRIXDIR") == NULL){ - std::cerr << "Please, specify the location of the matrices with -d mat_folder or the environment variable EIGEN_MATRIXDIR \n"; - std::cerr << " Run with --help to see the list of all the available options \n"; - return -1; - } - matrix_dir = getenv("EIGEN_MATRIXDIR"); - } - - std::ofstream statbuf; - string statFile ; - - // Get the file to write the statistics - bool statFileExists = get_options(argc, args, "-o", &statFile); - if(statFileExists) - { - statbuf.open(statFile.c_str(), std::ios::out); - if(statbuf.good()){ - statFileExists = true; - printStatheader(statbuf); - statbuf.close(); - } - else - std::cerr << "Unable to open the provided file for writting... \n"; - } - - // Get the maximum number of iterations and the tolerance - int maxiters = 1000; - double tol = 1e-08; - string inval; - if (get_options(argc, args, "--eps", &inval)) - tol = atof(inval.c_str()); - if(get_options(argc, args, "--maxits", &inval)) - maxiters = atoi(inval.c_str()); - - string current_dir; - // Test the real-arithmetics matrices - Browse_Matrices(matrix_dir, statFileExists, statFile,maxiters, tol); - - // Test the complex-arithmetics matrices - Browse_Matrices >(matrix_dir, statFileExists, statFile, maxiters, tol); - - if(statFileExists) - { - statbuf.open(statFile.c_str(), std::ios::app); - statbuf << " \n"; - cout << "\n Output written in " << statFile << " ...\n"; - statbuf.close(); - } - - return 0; -} - - diff --git a/eigen3/bench/spbench/spbenchsolver.h b/eigen3/bench/spbench/spbenchsolver.h deleted file mode 100644 --- a/eigen3/bench/spbench/spbenchsolver.h +++ /dev/null @@ -1,554 +0,0 @@ -// This file is part of Eigen, a lightweight C++ template library -// for linear algebra. -// -// Copyright (C) 2012 Désiré Nuentsa-Wakam -// -// This Source Code Form is subject to the terms of the Mozilla -// Public License v. 2.0. If a copy of the MPL was not distributed -// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. - - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "spbenchstyle.h" - -#ifdef EIGEN_METIS_SUPPORT -#include -#endif - -#ifdef EIGEN_CHOLMOD_SUPPORT -#include -#endif - -#ifdef EIGEN_UMFPACK_SUPPORT -#include -#endif - -#ifdef EIGEN_PARDISO_SUPPORT -#include -#endif - -#ifdef EIGEN_SUPERLU_SUPPORT -#include -#endif - -#ifdef EIGEN_PASTIX_SUPPORT -#include -#endif - -// CONSTANTS -#define EIGEN_UMFPACK 10 -#define EIGEN_SUPERLU 20 -#define EIGEN_PASTIX 30 -#define EIGEN_PARDISO 40 -#define EIGEN_SPARSELU_COLAMD 50 -#define EIGEN_SPARSELU_METIS 51 -#define EIGEN_BICGSTAB 60 -#define EIGEN_BICGSTAB_ILUT 61 -#define EIGEN_GMRES 70 -#define EIGEN_GMRES_ILUT 71 -#define EIGEN_SIMPLICIAL_LDLT 80 -#define EIGEN_CHOLMOD_LDLT 90 -#define EIGEN_PASTIX_LDLT 100 -#define EIGEN_PARDISO_LDLT 110 -#define EIGEN_SIMPLICIAL_LLT 120 -#define EIGEN_CHOLMOD_SUPERNODAL_LLT 130 -#define EIGEN_CHOLMOD_SIMPLICIAL_LLT 140 -#define EIGEN_PASTIX_LLT 150 -#define EIGEN_PARDISO_LLT 160 -#define EIGEN_CG 170 -#define EIGEN_CG_PRECOND 180 - -using namespace Eigen; -using namespace std; - - -// Global variables for input parameters -int MaximumIters; // Maximum number of iterations -double RelErr; // Relative error of the computed solution -double best_time_val; // Current best time overall solvers -int best_time_id; // id of the best solver for the current system - -template inline typename NumTraits::Real test_precision() { return NumTraits::dummy_precision(); } -template<> inline float test_precision() { return 1e-3f; } -template<> inline double test_precision() { return 1e-6; } -template<> inline float test_precision >() { return test_precision(); } -template<> inline double test_precision >() { return test_precision(); } - -void printStatheader(std::ofstream& out) -{ - // Print XML header - // NOTE It would have been much easier to write these XML documents using external libraries like tinyXML or Xerces-C++. - - out << " \n"; - out << " \n"; - out << "\n]>"; - out << "\n\n\n"; - - out << "\n \n" ; //root XML element - // Print the xsl style section - printBenchStyle(out); - // List all available solvers - out << " \n"; -#ifdef EIGEN_UMFPACK_SUPPORT - out <<" \n"; - out << " LU \n"; - out << " UMFPACK \n"; - out << " \n"; -#endif -#ifdef EIGEN_SUPERLU_SUPPORT - out <<" \n"; - out << " LU \n"; - out << " SUPERLU \n"; - out << " \n"; -#endif -#ifdef EIGEN_CHOLMOD_SUPPORT - out <<" \n"; - out << " LLT SP \n"; - out << " CHOLMOD \n"; - out << " \n"; - - out <<" \n"; - out << " LLT \n"; - out << " CHOLMOD \n"; - out << " \n"; - - out <<" \n"; - out << " LDLT \n"; - out << " CHOLMOD \n"; - out << " \n"; -#endif -#ifdef EIGEN_PARDISO_SUPPORT - out <<" \n"; - out << " LU \n"; - out << " PARDISO \n"; - out << " \n"; - - out <<" \n"; - out << " LLT \n"; - out << " PARDISO \n"; - out << " \n"; - - out <<" \n"; - out << " LDLT \n"; - out << " PARDISO \n"; - out << " \n"; -#endif -#ifdef EIGEN_PASTIX_SUPPORT - out <<" \n"; - out << " LU \n"; - out << " PASTIX \n"; - out << " \n"; - - out <<" \n"; - out << " LLT \n"; - out << " PASTIX \n"; - out << " \n"; - - out <<" \n"; - out << " LDLT \n"; - out << " PASTIX \n"; - out << " \n"; -#endif - - out <<" \n"; - out << " BICGSTAB \n"; - out << " EIGEN \n"; - out << " \n"; - - out <<" \n"; - out << " BICGSTAB_ILUT \n"; - out << " EIGEN \n"; - out << " \n"; - - out <<" \n"; - out << " GMRES_ILUT \n"; - out << " EIGEN \n"; - out << " \n"; - - out <<" \n"; - out << " LDLT \n"; - out << " EIGEN \n"; - out << " \n"; - - out <<" \n"; - out << " LLT \n"; - out << " EIGEN \n"; - out << " \n"; - - out <<" \n"; - out << " CG \n"; - out << " EIGEN \n"; - out << " \n"; - - out <<" \n"; - out << " LU_COLAMD \n"; - out << " EIGEN \n"; - out << " \n"; - -#ifdef EIGEN_METIS_SUPPORT - out <<" \n"; - out << " LU_METIS \n"; - out << " EIGEN \n"; - out << " \n"; -#endif - out << " \n"; - -} - - -template -void call_solver(Solver &solver, const int solver_id, const typename Solver::MatrixType& A, const Matrix& b, const Matrix& refX,std::ofstream& statbuf) -{ - - double total_time; - double compute_time; - double solve_time; - double rel_error; - Matrix x; - BenchTimer timer; - timer.reset(); - timer.start(); - solver.compute(A); - if (solver.info() != Success) - { - std::cerr << "Solver failed ... \n"; - return; - } - timer.stop(); - compute_time = timer.value(); - statbuf << "