LinkNexus/huoyi_deploy
20
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
huangweifeng
2026-10-22 09:23:54 +08:00
commit 63f557a39f
4448 changed files with 584487 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third_party/eigen/bench/btl/libs/mtl4/.kdbgrc.main
Vendored
+12
View File
@@ -0,0 +1,12 @@
[General]
DebuggerCmdStr=
DriverName=GDB
FileVersion=1
OptionsSelected=
ProgramArgs=
TTYLevel=7
WorkingDirectory=
[Memory]
ColumnWidths=80,0
NumExprs=0
third_party/eigen/bench/btl/libs/mtl4/CMakeLists.txt
Vendored
+6
View File
@@ -0,0 +1,6 @@
find_package(MTL4)
if (MTL4_FOUND)
include_directories(${MTL4_INCLUDE_DIR})
btl_add_bench(btl_mtl4 main.cpp)
endif ()
third_party/eigen/bench/btl/libs/mtl4/main.cpp
Vendored
+42
View File
@@ -0,0 +1,42 @@
//=====================================================
// 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.
//
#include "utilities.h"
#include "mtl4_interface.hh"
#include "bench.hh"
#include "basic_actions.hh"
#include "action_cholesky.hh"
// #include "action_lu_decomp.hh"
BTL_MAIN;
int main() {
bench<Action_axpy<mtl4_interface<REAL_TYPE> > >(MIN_AXPY, MAX_AXPY, NB_POINT);
bench<Action_axpby<mtl4_interface<REAL_TYPE> > >(MIN_AXPY, MAX_AXPY, NB_POINT);
bench<Action_matrix_vector_product<mtl4_interface<REAL_TYPE> > >(MIN_MV, MAX_MV, NB_POINT);
bench<Action_atv_product<mtl4_interface<REAL_TYPE> > >(MIN_MV, MAX_MV, NB_POINT);
bench<Action_matrix_matrix_product<mtl4_interface<REAL_TYPE> > >(MIN_MM, MAX_MM, NB_POINT);
// bench<Action_ata_product<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
// bench<Action_aat_product<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
bench<Action_trisolve<mtl4_interface<REAL_TYPE> > >(MIN_MM, MAX_MM, NB_POINT);
// bench<Action_cholesky<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
// bench<Action_lu_decomp<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
return 0;
}
third_party/eigen/bench/btl/libs/mtl4/mtl4_LU_solve_interface.hh
Vendored
+160
View File
@@ -0,0 +1,160 @@
//=====================================================
// File : blitz_LU_solve_interface.hh
// Author : L. Plagne <laurent.plagne@edf.fr)>
// Copyright (C) EDF R&D, lun sep 30 14:23:31 CEST 2002
//=====================================================
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
#ifndef BLITZ_LU_SOLVE_INTERFACE_HH
#define BLITZ_LU_SOLVE_INTERFACE_HH
#include "blitz/array.h"
#include <vector>
BZ_USING_NAMESPACE(blitz)
template <class real>
class blitz_LU_solve_interface : public blitz_interface<real> {
public:
typedef typename blitz_interface<real>::gene_matrix gene_matrix;
typedef typename blitz_interface<real>::gene_vector gene_vector;
typedef blitz::Array<int, 1> Pivot_Vector;
inline static void new_Pivot_Vector(Pivot_Vector &pivot, int N) { pivot.resize(N); }
inline static void free_Pivot_Vector(Pivot_Vector &pivot) { return; }
static inline real matrix_vector_product_sliced(const gene_matrix &A, gene_vector B, int row, int col_start,
int col_end) {
real somme = 0.;
for (int j = col_start; j < col_end + 1; j++) {
somme += A(row, j) * B(j);
}
return somme;
}
static inline real matrix_matrix_product_sliced(gene_matrix &A, int row, int col_start, int col_end, gene_matrix &B,
int row_shift, int col) {
real somme = 0.;
for (int j = col_start; j < col_end + 1; j++) {
somme += A(row, j) * B(j + row_shift, col);
}
return somme;
}
inline static void LU_factor(gene_matrix &LU, Pivot_Vector &pivot, int N) {
ASSERT(LU.rows() == LU.cols());
int index_max = 0;
real big = 0.;
real theSum = 0.;
real dum = 0.;
// Get the implicit scaling information :
gene_vector ImplicitScaling(N);
for (int i = 0; i < N; i++) {
big = 0.;
for (int j = 0; j < N; j++) {
if (abs(LU(i, j)) >= big) big = abs(LU(i, j));
}
if (big == 0.) {
INFOS("blitz_LU_factor::Singular matrix");
exit(0);
}
ImplicitScaling(i) = 1. / big;
}
// Loop over columns of Crout's method :
for (int j = 0; j < N; j++) {
for (int i = 0; i < j; i++) {
theSum = LU(i, j);
theSum -= matrix_matrix_product_sliced(LU, i, 0, i - 1, LU, 0, j);
// theSum -= sum( LU( i, Range( fromStart, i-1 ) )*LU( Range( fromStart, i-1 ), j ) ) ;
LU(i, j) = theSum;
}
// Search for the largest pivot element :
big = 0.;
for (int i = j; i < N; i++) {
theSum = LU(i, j);
theSum -= matrix_matrix_product_sliced(LU, i, 0, j - 1, LU, 0, j);
// theSum -= sum( LU( i, Range( fromStart, j-1 ) )*LU( Range( fromStart, j-1 ), j ) ) ;
LU(i, j) = theSum;
if ((ImplicitScaling(i) * abs(theSum)) >= big) {
dum = ImplicitScaling(i) * abs(theSum);
big = dum;
index_max = i;
}
}
// Interchanging rows and the scale factor :
if (j != index_max) {
for (int k = 0; k < N; k++) {
dum = LU(index_max, k);
LU(index_max, k) = LU(j, k);
LU(j, k) = dum;
}
ImplicitScaling(index_max) = ImplicitScaling(j);
}
pivot(j) = index_max;
if (LU(j, j) == 0.) LU(j, j) = 1.e-20;
// Divide by the pivot element :
if (j < N) {
dum = 1. / LU(j, j);
for (int i = j + 1; i < N; i++) LU(i, j) *= dum;
}
}
}
inline static void LU_solve(const gene_matrix &LU, const Pivot_Vector pivot, gene_vector &B, gene_vector X, int N) {
// Pour conserver le meme header, on travaille sur X, copie du second-membre B
X = B.copy();
ASSERT(LU.rows() == LU.cols());
firstIndex indI;
// Forward substitution :
int ii = 0;
real theSum = 0.;
for (int i = 0; i < N; i++) {
int ip = pivot(i);
theSum = X(ip);
// theSum = B( ip ) ;
X(ip) = X(i);
// B( ip ) = B( i ) ;
if (ii) {
theSum -= matrix_vector_product_sliced(LU, X, i, ii - 1, i - 1);
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*X( Range( ii-1, i-1 ) ) ) ;
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*B( Range( ii-1, i-1 ) ) ) ;
} else if (theSum) {
ii = i + 1;
}
X(i) = theSum;
// B( i ) = theSum ;
}
// Backsubstitution :
for (int i = N - 1; i >= 0; i--) {
theSum = X(i);
// theSum = B( i ) ;
theSum -= matrix_vector_product_sliced(LU, X, i, i + 1, N);
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*X( Range( i+1, toEnd ) ) ) ;
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*B( Range( i+1, toEnd ) ) ) ;
// Store a component of the solution vector :
X(i) = theSum / LU(i, i);
// B( i ) = theSum/LU( i, i ) ;
}
}
};
#endif
third_party/eigen/bench/btl/libs/mtl4/mtl4_interface.hh
Vendored
+124
View File
@@ -0,0 +1,124 @@
//=====================================================
// 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 MTL4_INTERFACE_HH
#define MTL4_INTERFACE_HH
#include <boost/numeric/mtl/mtl.hpp>
#include <boost/numeric/mtl/utility/range_generator.hpp>
// #include <boost/numeric/mtl/operation/cholesky.hpp>
#include <vector>
using namespace mtl;
template <class real>
class mtl4_interface {
public:
typedef real real_type;
typedef std::vector<real> stl_vector;
typedef std::vector<stl_vector> stl_matrix;
typedef mtl::dense2D<real, mtl::matrix::parameters<mtl::tag::col_major> > gene_matrix;
typedef mtl::dense_vector<real> gene_vector;
static inline std::string name() { return "mtl4"; }
static void free_matrix(gene_matrix& A, int N) { return; }
static void free_vector(gene_vector& B) { return; }
static inline void matrix_from_stl(gene_matrix& A, stl_matrix& A_stl) {
A.change_dim(A_stl[0].size(), A_stl.size());
for (int j = 0; j < A_stl.size(); j++) {
for (int i = 0; i < A_stl[j].size(); i++) {
A(i, j) = A_stl[j][i];
}
}
}
static inline void vector_from_stl(gene_vector& B, stl_vector& B_stl) {
B.change_dim(B_stl.size());
for (int i = 0; i < B_stl.size(); i++) {
B[i] = B_stl[i];
}
}
static inline void vector_to_stl(gene_vector& B, stl_vector& B_stl) {
for (int i = 0; i < B_stl.size(); i++) {
B_stl[i] = B[i];
}
}
static inline void matrix_to_stl(gene_matrix& A, stl_matrix& A_stl) {
int N = A_stl.size();
for (int j = 0; j < N; j++) {
A_stl[j].resize(N);
for (int i = 0; i < N; i++) {
A_stl[j][i] = A(i, j);
}
}
}
static inline void matrix_matrix_product(const gene_matrix& A, const gene_matrix& B, gene_matrix& X, int N) {
X = (A * B);
// morton_dense<double, doppled_64_row_mask> C(N,N);
// C = B;
// X = (A*C);
}
static inline void transposed_matrix_matrix_product(const gene_matrix& A, const gene_matrix& B, gene_matrix& X,
int N) {
X = (trans(A) * trans(B));
}
// static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N){
// X = (trans(A)*A);
// }
static inline void aat_product(const gene_matrix& A, gene_matrix& X, int N) { X = (A * trans(A)); }
static inline void matrix_vector_product(gene_matrix& A, gene_vector& B, gene_vector& X, int N) { X = (A * B); }
static inline void atv_product(gene_matrix& A, gene_vector& B, gene_vector& X, int N) { X = (trans(A) * B); }
static inline void axpy(const real coef, const gene_vector& X, gene_vector& Y, int N) { Y += coef * X; }
static inline void axpby(real a, const gene_vector& X, real b, gene_vector& Y, int N) { Y = a * X + b * Y; }
// static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){
// C = X;
// recursive_cholesky(C);
// }
// static inline void lu_decomp(const gene_matrix & X, gene_matrix & R, int N){
// R = X;
// std::vector<int> ipvt(N);
// lu_factor(R, ipvt);
// }
static inline void trisolve_lower(const gene_matrix& L, const gene_vector& B, gene_vector& X, int N) {
X = lower_trisolve(L, B);
}
static inline void copy_matrix(const gene_matrix& source, gene_matrix& cible, int N) { cible = source; }
static inline void copy_vector(const gene_vector& source, gene_vector& cible, int N) { cible = source; }
};
#endif