Add files using upload-large-folder tool

include/eigen/bench/btl/CMakeLists.txt

@@ -0,0 +1,107 @@
+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 ${CMAKE_CXX_FLAGS}")
+  set(CMAKE_Fortran_FLAGS "-g0 -O3 -DNDEBUG ${CMAKE_Fortran_FLAGS}")
+  if(BTL_NOVEC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEIGEN_DONT_VECTORIZE")
+  endif(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(BTL_NOVEC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEIGEN_DONT_VECTORIZE")
+  endif(BTL_NOVEC)
+endif(MSVC)
+
+if(IS_ICPC)
+  set(CMAKE_CXX_FLAGS "-fast ${CMAKE_CXX_FLAGS}")
+  set(CMAKE_Fortran_FLAGS "-fast ${CMAKE_Fortran_FLAGS}")
+endif()
+
+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 ()
+
+find_library(EIGEN_BTL_RT_LIBRARY rt)
+# if we cannot find it easily, then we don't need it!
+if(NOT EIGEN_BTL_RT_LIBRARY)
+  set(EIGEN_BTL_RT_LIBRARY "")
+endif()
+
+macro(BTL_ADD_BENCH targetname)
+
+  foreach(_current_var ${ARGN})
+    set(_last_var ${_current_var})
+  endforeach()
+
+  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 ()
+
+  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} ${EIGEN_BTL_RT_LIBRARY})
+  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()
+
+enable_testing()
+
+add_subdirectory(libs/eigen3)
+add_subdirectory(libs/eigen2)
+add_subdirectory(libs/tensors)
+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(libs/blaze)
+
+add_subdirectory(data)
+
+

include/eigen/bench/btl/COPYING

@@ -0,0 +1,340 @@
+                    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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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.
+
+  <signature of Ty Coon>, 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.

include/eigen/bench/btl/README

@@ -0,0 +1,154 @@
+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 <regexp>
+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 example:
+  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<real_type>
+	*** stl_matrix : must correspond to std::vector<stl_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<Portable_Perf_Analyzer,Action>(size_min,size_max,nb_point);
+ with
+     bench<Mixed_Perf_Analyzer,Action>(size_min,size_max,nb_point);
+ in generic/bench.hh
+
+.
+
+
+

include/eigen/bench/btl/actions/action_aat_product.hh

@@ -0,0 +1,145 @@
+//=====================================================
+// File   :  action_aat_product.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_matrix<null_function>(X_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::aat_product(A_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_ata_product.hh

@@ -0,0 +1,145 @@
+//=====================================================
+// File   :  action_ata_product.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_matrix<null_function>(X_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::ata_product(A_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_atv_product.hh

@@ -0,0 +1,134 @@
+//=====================================================
+// File   :  action_atv_product.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_atv_product {
+
+public :
+
+  Action_atv_product( int size ) : _size(size)
+  {
+    MESSAGE("Action_atv_product Ctor");
+
+    // STL matrix and vector initialization
+
+    init_matrix<pseudo_random>(A_stl,_size);
+    init_vector<pseudo_random>(B_stl,_size);
+    init_vector<null_function>(X_stl,_size);
+    init_vector<null_function>(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<typename Interface::real_type>::atv_product(A_stl,B_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_axpby.hh

@@ -0,0 +1,127 @@
+//=====================================================
+// File   :  action_axpby.hh
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//=====================================================
+//
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_axpby {
+
+public :
+
+  // Ctor
+  Action_axpby( int size ):_alpha(0.5),_beta(0.95),_size(size)
+  {
+    MESSAGE("Action_axpby Ctor");
+
+    // STL vector initialization
+    init_vector<pseudo_random>(X_stl,_size);
+    init_vector<pseudo_random>(Y_stl,_size);
+    init_vector<null_function>(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<typename Interface::real_type>::axpby(_alpha,X_stl,_beta,Y_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_axpy.hh

@@ -0,0 +1,139 @@
+//=====================================================
+// File   :  action_axpy.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_axpy {
+
+public :
+
+  // Ctor
+
+  Action_axpy( int size ):_coef(1.0),_size(size)
+  {
+    MESSAGE("Action_axpy Ctor");
+
+    // STL vector initialization
+
+    init_vector<pseudo_random>(X_stl,_size);
+    init_vector<pseudo_random>(Y_stl,_size);
+    init_vector<null_function>(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<typename Interface::real_type>::axpy(_coef,X_stl,Y_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_cholesky.hh

@@ -0,0 +1,128 @@
+//=====================================================
+// File   :  action_cholesky.hh
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//=====================================================
+//
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_cholesky {
+
+public :
+
+  // Ctor
+
+  Action_cholesky( int size ):_size(size)
+  {
+    MESSAGE("Action_cholesky Ctor");
+
+    // STL mat/vec initialization
+    init_matrix_symm<pseudo_random>(X_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::cholesky(X_stl,C_stl,_size);
+//
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_ger.hh

@@ -0,0 +1,128 @@
+
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_vector<pseudo_random>(B_stl,_size);
+    init_vector<pseudo_random>(X_stl,_size);
+    init_vector<null_function>(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<typename Interface::real_type>::ger(A_stl,B_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_hessenberg.hh

@@ -0,0 +1,233 @@
+//=====================================================
+// File   :  action_hessenberg.hh
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//=====================================================
+//
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_hessenberg {
+
+public :
+
+  // Ctor
+
+  Action_hessenberg( int size ):_size(size)
+  {
+    MESSAGE("Action_hessenberg Ctor");
+
+    // STL vector initialization
+    init_matrix<pseudo_random>(X_stl,_size);
+
+    init_matrix<null_function>(C_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::hessenberg(X_stl,C_stl,_size);
+//
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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 Interface>
+class Action_tridiagonalization {
+
+public :
+
+  // Ctor
+
+  Action_tridiagonalization( int size ):_size(size)
+  {
+    MESSAGE("Action_tridiagonalization Ctor");
+
+    // STL vector initialization
+    init_matrix<pseudo_random>(X_stl,_size);
+    
+    for(int i=0; i<_size; ++i)
+    {
+      for(int j=0; j<i; ++j)
+        X_stl[i][j] = X_stl[j][i];
+    }
+    
+    init_matrix<null_function>(C_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::tridiagonalization(X_stl,C_stl,_size);
+//
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_lu_decomp.hh

@@ -0,0 +1,124 @@
+//=====================================================
+// File   :  action_lu_decomp.hh
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//=====================================================
+//
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_lu_decomp {
+
+public :
+
+  // Ctor
+
+  Action_lu_decomp( int size ):_size(size)
+  {
+    MESSAGE("Action_lu_decomp Ctor");
+
+    // STL vector initialization
+    init_matrix<pseudo_random>(X_stl,_size);
+
+    init_matrix<null_function>(C_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::lu_decomp(X_stl,C_stl,_size);
+//
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_lu_solve.hh

@@ -0,0 +1,136 @@
+//=====================================================
+// File   :  action_lu_solve.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>        
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,size);
+    init_vector<pseudo_random>(B_stl,size);
+    init_vector<null_function>(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<nb_calc;ii++){
+
+      // LU factorization
+      Interface::copy_matrix(A,LU,size);
+      Interface::LU_factor(LU,pivot,size);
+      
+      // LU solve
+
+      Interface::LU_solve(LU,pivot,B,X,size);
+
+    }
+
+    // Time stop
+
+    chronos.stop();
+
+    double time=chronos.user_time();
+  
+    // check result :
+
+    typename Interface::stl_vector B_new_stl(size);
+    Interface::vector_to_stl(X,X_stl);
+
+    STL_interface<typename Interface::real_type>::matrix_vector_product(A_stl,X_stl,B_new_stl,size); 
+  
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::norm_diff(B_stl,B_new_stl);
+    
+    if (error>1.e-5){
+      INFOS("WRONG CALCULATION...residual=" << error);
+      STL_interface<typename Interface::real_type>::display_vector(B_stl);
+      STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_matrix_matrix_product.hh

@@ -0,0 +1,150 @@
+//=====================================================
+// File   :  action_matrix_matrix_product.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_matrix<pseudo_random>(B_stl,_size);
+    init_matrix<null_function>(X_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,_size);
+      typename Interface::real_type error=
+        STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_matrix_matrix_product_bis.hh

@@ -0,0 +1,152 @@
+//=====================================================
+// File   :  action_matrix_matrix_product_bis.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init_function.hh"
+#include "init_vector.hh"
+#include "init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,size);
+    init_matrix<pseudo_random>(B_stl,size);
+    init_matrix<null_function>(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<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_matrix_vector_product.hh

@@ -0,0 +1,153 @@
+//=====================================================
+// File   :  action_matrix_vector_product.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_vector<pseudo_random>(B_stl,_size);
+    init_vector<null_function>(X_stl,_size);
+    init_vector<null_function>(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<typename Interface::real_type>::matrix_vector_product(A_stl,B_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_partial_lu.hh

@@ -0,0 +1,125 @@
+//=====================================================
+// File   :  action_lu_decomp.hh
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//=====================================================
+//
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_partial_lu {
+
+public :
+
+  // Ctor
+
+  Action_partial_lu( int size ):_size(size)
+  {
+    MESSAGE("Action_partial_lu Ctor");
+
+    // STL vector initialization
+    init_matrix<pseudo_random>(X_stl,_size);
+    init_matrix<null_function>(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<typename Interface::real_type>::lu_decomp(X_stl,C_stl,_size);
+//
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_rot.hh

@@ -0,0 +1,116 @@
+
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_vector<pseudo_random>(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<typename Interface::real_type>::rot(A_stl,B_stl,X_stl,_size);
+
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_symv.hh

@@ -0,0 +1,139 @@
+//=====================================================
+// File   :  action_symv.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_vector<pseudo_random>(B_stl,_size);
+    init_vector<null_function>(X_stl,_size);
+    init_vector<null_function>(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<typename Interface::real_type>::symv(A_stl,B_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_syr2.hh

@@ -0,0 +1,133 @@
+//=====================================================
+// File   :  action_syr2.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_vector<pseudo_random>(B_stl,_size);
+    init_vector<pseudo_random>(X_stl,_size);
+    init_vector<null_function>(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<typename Interface::real_type>::syr2(A_stl,B_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_trisolve.hh

@@ -0,0 +1,137 @@
+//=====================================================
+// File   :  action_trisolve.hh
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//=====================================================
+//
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_trisolve {
+
+public :
+
+  // Ctor
+
+  Action_trisolve( int size ):_size(size)
+  {
+    MESSAGE("Action_trisolve Ctor");
+
+    // STL vector initialization
+    init_matrix<pseudo_random>(L_stl,_size);
+    init_vector<pseudo_random>(B_stl,_size);
+    init_vector<null_function>(X_stl,_size);
+    for (int j=0; j<_size; ++j)
+    {
+      for (int i=0; i<j; ++i)
+        L_stl[j][i] = 0;
+      L_stl[j][j] += 3;
+    }
+
+    init_vector<null_function>(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<typename Interface::real_type>::trisolve_lower(L_stl,B_stl,X_stl,_size);
+
+    typename Interface::real_type error=
+      STL_interface<typename Interface::real_type>::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

include/eigen/bench/btl/actions/action_trisolve_matrix.hh

@@ -0,0 +1,165 @@
+//=====================================================
+// File   :  action_matrix_matrix_product.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+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<pseudo_random>(A_stl,_size);
+    init_matrix<pseudo_random>(B_stl,_size);
+    init_matrix<null_function>(X_stl,_size);
+    init_matrix<null_function>(resu_stl,_size);
+
+    for (int j=0; j<_size; ++j)
+    {
+      for (int i=0; i<j; ++i)
+        A_stl[j][i] = 0;
+      A_stl[j][j] += 3;
+    }
+
+    // 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);
+
+    _cost = 0;
+    for (int j=0; j<_size; ++j)
+    {
+      _cost += 2*j + 1;
+    }
+    _cost *= _size;
+  }
+
+  // invalidate copy ctor
+
+  Action_trisolve_matrix( const  Action_trisolve_matrix & )
+  {
+    INFOS("illegal call to Action_trisolve_matrix Copy Ctor");
+    exit(0);
+  }
+
+  // Dtor
+
+  ~Action_trisolve_matrix( void ){
+
+    MESSAGE("Action_trisolve_matrix 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 "trisolve_matrix_"+Interface::name();
+  }
+
+  double nb_op_base( void ){
+    return _cost;
+  }
+
+  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::trisolve_lower_matrix(A,B,X,_size);
+  }
+
+  void check_result( void ){
+
+    // calculation check
+
+//     Interface::matrix_to_stl(X,resu_stl);
+//
+//     STL_interface<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,_size);
+//
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/action_trmm.hh

@@ -0,0 +1,165 @@
+//=====================================================
+// File   :  action_matrix_matrix_product.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <string>
+#include "init/init_function.hh"
+#include "init/init_vector.hh"
+#include "init/init_matrix.hh"
+
+using namespace std;
+
+template<class Interface>
+class Action_trmm {
+
+public :
+
+  // Ctor
+
+  Action_trmm( int size ):_size(size)
+  {
+    MESSAGE("Action_trmm Ctor");
+
+    // STL matrix and vector initialization
+
+    init_matrix<pseudo_random>(A_stl,_size);
+    init_matrix<pseudo_random>(B_stl,_size);
+    init_matrix<null_function>(X_stl,_size);
+    init_matrix<null_function>(resu_stl,_size);
+
+    for (int j=0; j<_size; ++j)
+    {
+      for (int i=0; i<j; ++i)
+        A_stl[j][i] = 0;
+      A_stl[j][j] += 3;
+    }
+
+    // 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);
+
+    _cost = 0;
+    for (int j=0; j<_size; ++j)
+    {
+      _cost += 2*j + 1;
+    }
+    _cost *= _size;
+  }
+
+  // invalidate copy ctor
+
+  Action_trmm( const  Action_trmm & )
+  {
+    INFOS("illegal call to Action_trmm Copy Ctor");
+    exit(0);
+  }
+
+  // Dtor
+
+  ~Action_trmm( void ){
+
+    MESSAGE("Action_trmm 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 "trmm_"+Interface::name();
+  }
+
+  double nb_op_base( void ){
+    return _cost;
+  }
+
+  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::trmm(A,B,X,_size);
+  }
+
+  void check_result( void ){
+
+    // calculation check
+
+//     Interface::matrix_to_stl(X,resu_stl);
+//
+//     STL_interface<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,_size);
+//
+//     typename Interface::real_type error=
+//       STL_interface<typename Interface::real_type>::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
+
+
+

include/eigen/bench/btl/actions/basic_actions.hh

@@ -0,0 +1,21 @@
+
+#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"
+

include/eigen/bench/btl/cmake/FindACML.cmake

@@ -0,0 +1,51 @@
+
+if (ACML_LIBRARIES)
+  set(ACML_FIND_QUIETLY TRUE)
+endif ()
+
+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
+  /usr/lib64
+  $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
+        /usr/lib64
+        $ENV{ACMLDIR}/lib
+        ${LIB_INSTALL_DIR}
+        )
+endif()
+
+
+
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(ACML DEFAULT_MSG ACML_LIBRARIES)
+
+mark_as_advanced(ACML_LIBRARIES)

include/eigen/bench/btl/cmake/FindATLAS.cmake

@@ -0,0 +1,31 @@
+
+if (ATLAS_LIBRARIES)
+  set(ATLAS_FIND_QUIETLY TRUE)
+endif ()
+
+find_file(ATLAS_LIB libatlas.so.3 PATHS /usr/lib /usr/lib/atlas /usr/lib64 /usr/lib64/atlas $ENV{ATLASDIR} ${LIB_INSTALL_DIR})
+find_library(ATLAS_LIB satlas PATHS $ENV{ATLASDIR} ${LIB_INSTALL_DIR})
+
+find_file(ATLAS_LAPACK NAMES liblapack_atlas.so.3 liblapack.so.3 PATHS /usr/lib /usr/lib/atlas /usr/lib64 /usr/lib64/atlas $ENV{ATLASDIR} ${LIB_INSTALL_DIR})
+find_library(ATLAS_LAPACK NAMES lapack_atlas lapack PATHS $ENV{ATLASDIR} ${LIB_INSTALL_DIR})
+
+find_file(ATLAS_F77BLAS libf77blas.so.3 PATHS /usr/lib /usr/lib/atlas /usr/lib64 /usr/lib64/atlas $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_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()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(ATLAS DEFAULT_MSG ATLAS_LIBRARIES)
+
+mark_as_advanced(ATLAS_LIBRARIES)

include/eigen/bench/btl/cmake/FindBLAZE.cmake

@@ -0,0 +1,31 @@
+# - Try to find eigen2 headers
+# Once done this will define
+#
+#  BLAZE_FOUND - system has blaze lib
+#  BLAZE_INCLUDE_DIR - the blaze include directory
+#
+# Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+# Adapted from FindEigen.cmake:
+# Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+if (BLAZE_INCLUDE_DIR)
+
+  # in cache already
+  set(BLAZE_FOUND TRUE)
+
+else ()
+
+find_path(BLAZE_INCLUDE_DIR NAMES blaze/Blaze.h
+     PATHS
+     ${INCLUDE_INSTALL_DIR}
+   )
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(BLAZE DEFAULT_MSG BLAZE_INCLUDE_DIR)
+
+mark_as_advanced(BLAZE_INCLUDE_DIR)
+
+endif()
+

include/eigen/bench/btl/cmake/FindBlitz.cmake

@@ -0,0 +1,40 @@
+# - 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, <montel@kde.org>
+# Copyright (c) 2007, Allen Winter, <winter@kde.org>
+# Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+# 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 ()
+
+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)

include/eigen/bench/btl/cmake/FindCBLAS.cmake

@@ -0,0 +1,35 @@
+# include(FindLibraryWithDebug)
+
+if (CBLAS_INCLUDES AND CBLAS_LIBRARIES)
+  set(CBLAS_FIND_QUIETLY TRUE)
+endif ()
+
+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
+  /usr/lib64
+  $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)

include/eigen/bench/btl/cmake/FindGMM.cmake

@@ -0,0 +1,17 @@
+if (GMM_INCLUDE_DIR)
+  # in cache already
+  set(GMM_FOUND TRUE)
+else ()
+
+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()

include/eigen/bench/btl/cmake/FindMKL.cmake

@@ -0,0 +1,65 @@
+
+if (MKL_LIBRARIES)
+  set(MKL_FIND_QUIETLY TRUE)
+endif ()
+
+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()
+
+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()
+
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MKL DEFAULT_MSG MKL_LIBRARIES)
+
+mark_as_advanced(MKL_LIBRARIES)

include/eigen/bench/btl/cmake/FindMTL4.cmake

@@ -0,0 +1,31 @@
+# - 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 <gael.guennebaud@inria.fr>
+# Adapted from FindEigen.cmake:
+# Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
+# 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 ()
+
+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()
+

include/eigen/bench/btl/cmake/FindOPENBLAS.cmake

@@ -0,0 +1,17 @@
+
+if (OPENBLAS_LIBRARIES)
+  set(OPENBLAS_FIND_QUIETLY TRUE)
+endif ()
+
+find_file(OPENBLAS_LIBRARIES NAMES libopenblas.so libopenblas.so.0 PATHS /usr/lib /usr/lib64 $ENV{OPENBLASDIR} ${LIB_INSTALL_DIR})
+find_library(OPENBLAS_LIBRARIES openblas PATHS $ENV{OPENBLASDIR} ${LIB_INSTALL_DIR})
+
+if(OPENBLAS_LIBRARIES AND CMAKE_COMPILER_IS_GNUCXX)
+  set(OPENBLAS_LIBRARIES ${OPENBLAS_LIBRARIES} "-lpthread -lgfortran")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OPENBLAS DEFAULT_MSG
+                                  OPENBLAS_LIBRARIES)
+
+mark_as_advanced(OPENBLAS_LIBRARIES)

include/eigen/bench/btl/cmake/FindPackageHandleStandardArgs.cmake

@@ -0,0 +1,60 @@
+# 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 <UPPERCASED_NAME>_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)

include/eigen/bench/btl/cmake/FindTvmet.cmake

@@ -0,0 +1,32 @@
+# - 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 <gael.guennebaud@inria.fr>
+# Adapted from FindEigen.cmake:
+# Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
+# 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 ()
+
+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()
+

include/eigen/bench/btl/cmake/MacroOptionalAddSubdirectory.cmake

@@ -0,0 +1,31 @@
+# - MACRO_OPTIONAL_ADD_SUBDIRECTORY() combines add_subdirectory() with an option()
+# MACRO_OPTIONAL_ADD_SUBDIRECTORY( <dir> )
+# 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, <neundorf@kde.org>
+#
+# 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)

include/eigen/bench/btl/data/CMakeLists.txt

@@ -0,0 +1,32 @@
+
+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)

include/eigen/bench/btl/data/action_settings.txt

@@ -0,0 +1,19 @@
+aat ; "{/*1.5 A x A^T}" ; "matrix size" ; 4:5000
+ata ; "{/*1.5 A^T x A}" ; "matrix size" ; 4:5000
+atv ; "{/*1.5 matrix^T x vector}" ; "matrix size" ; 4:5000
+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:5000
+matrix_vector ; "{/*1.5 matrix vector product}" ; "matrix size" ; 4:5000
+trmm ; "{/*1.5 triangular matrix matrix product}" ; "matrix size" ; 4:5000
+trisolve_vector ; "{/*1.5 triangular solver - vector (X = inv(L) X)}" ; "size" ; 4:5000
+trisolve_matrix ; "{/*1.5 triangular solver - matrix (M = inv(L) M)}" ; "size" ; 4:5000
+cholesky ; "{/*1.5 Cholesky decomposition}" ; "matrix size" ; 4:5000
+complete_lu_decomp ; "{/*1.5 Complete LU decomposition}" ; "matrix size" ; 4:5000
+partial_lu_decomp ; "{/*1.5 Partial LU decomposition}" ; "matrix size" ; 4:5000
+tridiagonalization ; "{/*1.5 Tridiagonalization}" ; "matrix size" ; 4:5000
+hessenberg ; "{/*1.5 Hessenberg decomposition}" ; "matrix size" ; 4:5000
+symv ; "{/*1.5 symmetric matrix vector product}" ; "matrix size" ; 4:5000
+syr2 ; "{/*1.5 symmretric rank-2 update (A += u^T v + u v^T)}" ; "matrix size" ; 4:5000
+ger ; "{/*1.5 general rank-1 update (A += u v^T)}" ; "matrix size" ; 4:5000
+rot ; "{/*1.5 apply rotation in the plane}" ; "vector size" ; 4:1000000

include/eigen/bench/btl/data/gnuplot_common_settings.hh

@@ -0,0 +1,87 @@
+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]
+

include/eigen/bench/btl/data/go_mean

@@ -0,0 +1,58 @@
+#!/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 '<p><strong>Configuration</strong>'  >> $webpagefilename
+echo '<ul>'\
+  '<li>' `cat /proc/cpuinfo | grep "model name" | head -n 1`\
+  '  (' `uname -m` ')</li>'\
+  '<li> compiler: ' `cat compiler_version.txt` '</li>'\
+  '<li> eigen3: ' `git ls-remote --refs  -q $EIGENDIR HEAD | cut  -f 1` '</li>'\
+  '</ul>' \
+  '</p>'  >> $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

include/eigen/bench/btl/data/mean.cxx

@@ -0,0 +1,182 @@
+//=====================================================
+// File   :  mean.cxx
+// Author :  L. Plagne <laurent.plagne@edf.fr)>        
+// 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 <vector>
+#include <string>
+#include <iostream>
+#include <fstream>
+#include "bench_parameter.hh"
+#include "utils/xy_file.hh"
+#include <set>
+
+using namespace std;
+
+double mean_calc(const vector<int> & tab_sizes, const vector<double> & 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<Lib_Mean> s_lib_mean ;
+
+  for (int i=6;i<argc;i++){
+    
+    string filename=argv[i];
+    
+    INFOS(filename);
+
+    double mic=0;
+    double moc=0;
+
+    {
+      
+      vector<int> tab_sizes;
+      vector<double> 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 << "<TABLE BORDER CELLPADDING=2>" << endl ;
+  cout << "  <TR>" << endl ;
+  cout << "    <TH ALIGN=CENTER> " << argv[1] << " </TH>" << endl ;
+  cout << "    <TH ALIGN=CENTER> <a href=""#mean_marker""> in cache <BR> mean perf <BR> Mflops </a></TH>" << endl ;
+  cout << "    <TH ALIGN=CENTER> in cache <BR> % best </TH>" << endl ;
+  cout << "    <TH ALIGN=CENTER> <a href=""#mean_marker""> out of cache <BR> mean perf <BR> Mflops </a></TH>" << endl ;
+  cout << "    <TH ALIGN=CENTER> out of cache <BR> % best </TH>" << endl ;
+  cout << "    <TH ALIGN=CENTER> details </TH>" << endl ;
+  cout << "    <TH ALIGN=CENTER> comments </TH>" << endl ;
+  cout << "  </TR>" << endl ;
+
+  multiset<Lib_Mean>::iterator is = s_lib_mean.begin();
+  Lib_Mean best(*is);  
+  
+
+  for (is=s_lib_mean.begin(); is!=s_lib_mean.end() ; is++){
+
+    cout << "  <TR>" << endl ;
+    cout << "     <TD> " << is->_lib_name << " </TD>" << endl ;
+    cout << "     <TD> " << is->_mean_in_cache << " </TD>" << endl ;
+    cout << "     <TD> " << 100*(is->_mean_in_cache/best._mean_in_cache) << " </TD>" << endl ;
+    cout << "     <TD> " << is->_mean_out_of_cache << " </TD>" << endl ;
+    cout << "     <TD> " << 100*(is->_mean_out_of_cache/best._mean_out_of_cache) << " </TD>" << endl ;
+    cout << "     <TD> " << 
+      "<a href=\"#"<<is->_lib_name<<"_"<<argv[1]<<"\">snippet</a>/" 
+      "<a href=\"#"<<is->_lib_name<<"_flags\">flags</a>  </TD>" << endl ;
+    cout << "     <TD> " << 
+      "<a href=\"#"<<is->_lib_name<<"_comments\">click here</a>  </TD>" << endl ;
+    cout << "  </TR>" << endl ;
+  
+  }
+
+  cout << "</TABLE>" << 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<int> & tab_sizes, const vector<double> & 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;i++){
+    
+    
+    if ((tab_sizes[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;
+}
+
+  
+
+

include/eigen/bench/btl/data/mk_gnuplot_script.sh

@@ -0,0 +1,68 @@
+#! /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
+
+
+
+

include/eigen/bench/btl/data/mk_mean_script.sh

@@ -0,0 +1,52 @@
+#! /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 '<br/>' >> $meanstatsfilename
+
+  webpagefilename=$2/index.html
+  # echo '<h3>'${WHAT}'</h3>'  >> $webpagefilename
+  echo '<hr/><a href="'$prefix$1'.pdf"><img src="'$prefix$1'.png" alt="'${WHAT}'" /></a><br/>'  >> $webpagefilename
+
+fi
+
+rm -R $WORK_DIR
+
+
+
+
+
+

include/eigen/bench/btl/data/mk_new_gnuplot.sh

@@ -0,0 +1,54 @@
+#!/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

include/eigen/bench/btl/data/perlib_plot_settings.txt

@@ -0,0 +1,16 @@
+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"
+OPENBLAS ;        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"
+blaze ;           with lines lw 3 lt 1 lc rgbcolor "#ff00ff"

include/eigen/bench/btl/data/regularize.cxx

@@ -0,0 +1,131 @@
+//=====================================================
+// File   :  regularize.cxx
+// Author :  L. Plagne <laurent.plagne@edf.fr)>        
+// 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 <vector>
+#include <string>
+#include <iostream>
+#include <fstream>
+#include "bench_parameter.hh"
+#include <set>
+
+using namespace std;
+
+void read_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops);
+void regularize_curve(const string & filename,
+		      const vector<double> & tab_mflops, 
+		      const vector<int> & 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="<<start_cut_size);
+
+  vector<int> tab_sizes;
+  vector<double> 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<double> & tab_mflops, 
+		      const vector<int> & 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]<start_cut_size){
+    
+    output_file << tab_sizes[i] << " " <<  tab_mflops[i] << endl ;
+    i++;
+
+  }
+    
+  output_file << endl ;
+
+  while(tab_sizes[i]<stop_cut_size){
+    
+    i++;
+
+  }
+
+  while(i<size){
+    
+    output_file << tab_sizes[i] << " " <<  tab_mflops[i] << endl ;
+    i++;
+
+  }
+
+  output_file.close();
+
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void read_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops){
+
+  ifstream input_file (filename.c_str(),ios::in) ;
+
+  if (!input_file){
+    INFOS("!!! Error opening "<<filename);
+    exit(0);
+  }
+  
+  int nb_point=0;
+  int size=0;
+  double mflops=0;
+
+  while (input_file >> size >> mflops ){
+    nb_point++;
+    tab_sizes.push_back(size);
+    tab_mflops.push_back(mflops);
+  }
+  SCRUTE(nb_point);
+
+  input_file.close();
+}
+

include/eigen/bench/btl/data/smooth.cxx

@@ -0,0 +1,198 @@
+//=====================================================
+// File   :  smooth.cxx
+// Author :  L. Plagne <laurent.plagne@edf.fr)>        
+// 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 <vector>
+#include <deque>
+#include <string>
+#include <iostream>
+#include <fstream>
+#include "bench_parameter.hh"
+#include <set>
+
+using namespace std;
+
+void read_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops);
+void write_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops);
+void smooth_curve(const vector<double> & tab_mflops, vector<double> & smooth_tab_mflops,int window_half_width);
+void centered_smooth_curve(const vector<double> & tab_mflops, vector<double> & 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="<<window_half_width);
+
+  vector<int> tab_sizes;
+  vector<double> tab_mflops;
+
+  read_xy_file(filename,tab_sizes,tab_mflops);
+
+  // smoothing
+
+  vector<double> 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<class VECTOR>
+double weighted_mean(const VECTOR & data)
+{
+
+  double mean=0.0;
+  
+  for (int i=0 ; i<data.size() ; i++){
+
+    mean+=data[i];
+
+  }
+
+  return mean/double(data.size()) ;
+
+}    
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+void smooth_curve(const vector<double> & tab_mflops, vector<double> & smooth_tab_mflops,int window_half_width){
+  
+  int window_width=2*window_half_width+1;
+
+  int size=tab_mflops.size();
+
+  vector<double> 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<double> & tab_mflops, vector<double> & 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<double> 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<size)) // inside of the vector
+	{ 
+	  sample.push_front(tab_mflops[before]);
+	  sample.push_back(tab_mflops[after]);
+	}
+    }
+    
+    smooth_tab_mflops.push_back(weighted_mean(sample));
+    
+  }
+
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void write_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & 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<int> & tab_sizes, vector<double> & tab_mflops){
+
+  ifstream input_file (filename.c_str(),ios::in) ;
+
+  if (!input_file){
+    INFOS("!!! Error opening "<<filename);
+    exit(0);
+  }
+  
+  int nb_point=0;
+  int size=0;
+  double mflops=0;
+
+  while (input_file >> size >> mflops ){
+    nb_point++;
+    tab_sizes.push_back(size);
+    tab_mflops.push_back(mflops);
+  }
+  SCRUTE(nb_point);
+
+  input_file.close();
+}
+

include/eigen/bench/btl/data/smooth_all.sh

@@ -0,0 +1,68 @@
+#! /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

include/eigen/bench/btl/generic_bench/bench.hh

@@ -0,0 +1,168 @@
+//=====================================================
+// File   :  bench.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 <iostream>
+#include "utilities.h"
+#include "size_lin_log.hh"
+#include "xy_file.hh"
+#include <vector>
+#include <string>
+#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 <template<class> 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 " <<filename);
+
+  // utilities
+
+  std::vector<double> tab_mflops(nb_point);
+  std::vector<int> tab_sizes(nb_point);
+
+  // matrices and vector size calculations
+  size_lin_log(nb_point,size_min,size_max,tab_sizes);
+
+  std::vector<int> oldSizes;
+  std::vector<double> oldFlops;
+  bool hasOldResults = read_xy_file(filename, oldSizes, oldFlops, true);
+  int oldi = oldSizes.size() - 1;
+
+  // loop on matrix size
+  Perf_Analyzer<Action> perf_action;
+  for (int i=nb_point-1;i>=0;i--)
+  {
+    //INFOS("size=" <<tab_sizes[i]<<"   ("<<nb_point-i<<"/"<<nb_point<<")");
+    std::cout << " " << "size = " << tab_sizes[i] << "  " << std::flush;
+
+    BTL_DISABLE_SSE_EXCEPTIONS();
+    #ifdef HAVE_MKL
+    {
+      float dummy;
+      cblas_saxpy(1,0,&dummy,1,&dummy,1);
+    }
+    #endif
+
+    tab_mflops[i] = perf_action.eval_mflops(tab_sizes[i]);
+    std::cout << tab_mflops[i];
+    
+    if (hasOldResults)
+    {
+      while (oldi>=0 && oldSizes[oldi]>tab_sizes[i])
+        --oldi;
+      if (oldi>=0 && oldSizes[oldi]==tab_sizes[i])
+      {
+        if (oldFlops[oldi]<tab_mflops[i])
+          std::cout << "\t > ";
+        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<int> newSizes;
+      std::vector<double> newFlops;
+      unsigned int i=0;
+      unsigned int j=0;
+      while (i<tab_sizes.size() && j<oldSizes.size())
+      {
+        if (tab_sizes[i] == oldSizes[j])
+        {
+          newSizes.push_back(tab_sizes[i]);
+          newFlops.push_back(std::max(tab_mflops[i], oldFlops[j]));
+          ++i;
+          ++j;
+        }
+        else if (tab_sizes[i] < oldSizes[j])
+        {
+          newSizes.push_back(tab_sizes[i]);
+          newFlops.push_back(tab_mflops[i]);
+          ++i;
+        }
+        else
+        {
+          newSizes.push_back(oldSizes[j]);
+          newFlops.push_back(oldFlops[j]);
+          ++j;
+        }
+      }
+      while (i<tab_sizes.size())
+      {
+        newSizes.push_back(tab_sizes[i]);
+        newFlops.push_back(tab_mflops[i]);
+        ++i;
+      }
+      while (j<oldSizes.size())
+      {
+        newSizes.push_back(oldSizes[j]);
+        newFlops.push_back(oldFlops[j]);
+        ++j;
+      }
+      tab_mflops = newFlops;
+      tab_sizes = newSizes;
+    }
+  }
+
+  // dump the result in a file  :
+  dump_xy_file(tab_sizes,tab_mflops,filename);
+
+}
+
+// default Perf Analyzer
+
+template <class Action>
+BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point ){
+
+  // if the rdtsc is not available :
+  bench<Portable_Perf_Analyzer,Action>(size_min,size_max,nb_point);
+  // if the rdtsc is available :
+//    bench<Mixed_Perf_Analyzer,Action>(size_min,size_max,nb_point);
+
+
+  // Only for small problem size. Otherwise it will be too long
+//   bench<X86_Perf_Analyzer,Action>(size_min,size_max,nb_point);
+//   bench<STL_Perf_Analyzer,Action>(size_min,size_max,nb_point);
+
+}
+
+#endif

include/eigen/bench/btl/generic_bench/bench_parameter.hh

@@ -0,0 +1,53 @@
+//=====================================================
+// File   :  bench_parameter.hh
+// Author :  L. Plagne <laurent.plagne@edf.fr)>
+// 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 3000000
+// min matrix size for matrix vector product bench
+#define MIN_MV 5
+// max matrix size for matrix vector product bench
+#define MAX_MV 5000
+// 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