C++博客-牵着老婆满街逛-随笔分类-Blitz++

The Matrix Template Library

杨粼波 — Sat, 01 Jul 2006 05:40:00 GMT

http://osl.iu.edu/research/mtl/

The Matrix Template Library (MTL) is a high-performance generic component library that provides comprehensive linear algebra functionality for a wide variety of matrix formats.

As with the Standard Template Library (STL), MTL uses a five-fold approach, consisting of generic functions, containers, iterators, adaptors, and function objects, all developed specifically for high performance numerical linear algebra. Within this framework, MTL provides generic algorithms corresponding to the mathematical operations that define linear algebra. Similarly, the containers, adaptors, and iterators are used to represent and to manipulate concrete linear algebra objects such as matrices and vectors.

To many scientific computing users, however, the advantages of an elegant programming interface are secondary to issues of performance. Generic programming is a powerful tool in this regard as well - performance tuning can itself be described in a generic fashion. These performance tuning abstractions are realized in a generic low-level library - the Basic Linear Algebra Instruction Set (BLAIS). Experimental results show that MTL with the BLAIS achieves performance that is as good as, or better than, vendor-tuned libraries. Thus, MTL demonstrates that the proper abstractions can be used to achieve high levels of performance, contrary to conventional wisdom. In addition, MTL requires orders of magnitude fewer lines of code for its implementation, with the concomitant savings in development and maintenance effort.

News

July 5, 2005: Distribution 2.1.2-22, which is adapted to the stricter syntax requirements in new compilers like gcc 4.0 can be downloaded here.
In parallel, Peter Gottschling and Dave Abrahams started the development of MTL version 4.0. It was planned to have an alpha version already released. "A good plan today is better than a perfect plan tomorrow" Robert De Niro said in "Wag the dog". This is certainly true for crisis management but we doubt the same applies for scientific software development.

Features

The Matrix Template Library is:

Generic, Orthogonal, and Comprehensive:: MTL includes a large number of data formats and algorithms, including most popular sparse and dense matrix formats and functionality equivalent to Level 3 BLAS.
Flexible and Extensible:: The MTL interface is designed to allow new functionality to be easily incorporated.
High Performance:: With a good optimizing compiler, such as KAI's C++, MTL provides performance equal to (and in many cases better than) vendor-tuned math libraries.
Reliable:: MTL is extensively tested on a regular basis.
Portable:: MTL is written in ANSI C++ and can be compiled and used on any target platform with an ANSI C++ compiler. Currently, compilers known to work are KAI's C++ on various platforms, MIPSp ro 7.3 on SGI, Visual C++ 6.0 and Metrowerks CodeWarrior Pro 5 on NT, egcs-2.91.60 and gcc 2.95.x on various platforms. See FAQ for more information.

Current Release

This is version 2.1.2 of MTL and its second full release. If you would like to be kept informed as new releases of MTL are made available, please subscribe to our announcement list.

杨粼波 2006-07-01 13:40 发表评论

vc.net2003下安装和使用blitz++详细指南

杨粼波 — Sat, 01 Jul 2006 05:34:00 GMT

摘要: @author:armylau @date:2004-8-12 一．起因安装和使用 blitz++ 时经常... 阅读全文

杨粼波 2006-07-01 13:34 发表评论

VC++ .NET 2003 –安装和使用Boost 1.30和Blitz++0.6

杨粼波 — Sat, 01 Jul 2006 05:29:00 GMT

摘要: 小气的神 2003-05-01 Article Type: In-Depth ... 阅读全文

杨粼波 2006-07-01 13:29 发表评论

在VS.net下安装使用blitz++科学计算库

杨粼波 — Sat, 01 Jul 2006 05:28:00 GMT

我做图像处理经常要用到矩阵运算，最常用到的工具就是matlab。不过matlab也就只能用在实验，真正做程序的时候，好多东西都要自己写，很麻烦。在网上搜了一下科学计算库，找到了三个，gsl、blitz++和MTL，没时间仔细研究哪个效率更高了，听了Oscargreat的推荐，开始用blitz++。

blitz++的代码下载下来发现，只是适合linux下编译，幸好在网上搜到了几篇不错的文档，在其指导下顺利的编译了blitz.lib。

体验：VC++ .NET 2003 –安装和使用Boost 1.30和Blitz++0.6
armylau的《VC.NET2003下安装和使用BLITZ++详细指南》原始出处不知道，大家可以自己去google，网上很多.

按照文档所述，编译blitz.lib和运行测试程序，都不会有问题。不过，我在尝试把blitz库用到自己的程序时，有了一些问题.

建了一个MFC应用程序，代码如下:

#include stdafx.h"
#include "config.h"
#include
using namespace blitz;
...

这样会报错。和Oscargreat分析了一会，发现是MFC和blitz冲突了，MFC居然把min和max用宏定义了（windef.h)，这样和blitz里的min和max冲突，暂时的解决办法是用#undef在前面屏蔽掉min和max，以后再找其他的办法吧。

还有就是blitz由于是C++ template库，所以，有很多情况下的应用是不需要链接blitz.lib的，但是最好还是链接上，因为blitz源文件里还是有一些cpp的。

杨粼波 2006-07-01 13:28 发表评论

标准库rand()函数的缺陷以及Blitz++随机数生成的简介

杨粼波 — Sat, 01 Jul 2006 05:27:00 GMT

摘要: （ newsuppy, 转载请注明出处）当我们需要在某个任务中使用随机数，通常我们习惯于使用标准库的rand函数。像这样：srand(time(0)); // 时间种子 rand() % MAX_RAND ； ... 阅读全文

杨粼波 2006-07-01 13:27 发表评论

Blitz++与MTL两大数值计算程序库(C++)的简介

杨粼波 — Sat, 01 Jul 2006 05:26:00 GMT

摘要: Blitz++ 与 MTL 两大数值计算程序库 (C++) 的简介 ... 阅读全文

杨粼波 2006-07-01 13:26 发表评论

Linux 下 Blitz++ 的安装

杨粼波 — Sat, 01 Jul 2006 05:24:00 GMT

1 下载 http://www.oonumerics.org/blitz/download/releases/blitz-0.6.tar.gz

2 tar zxvf blitz-0.6.tar.gz

3 ./configure

4 make

5 make install

杨粼波 2006-07-01 13:24 发表评论

Blitz++ 矩阵相乘(张量运算) 示例

杨粼波 — Sat, 01 Jul 2006 05:24:00 GMT

// 整理 by RobinKin
// Blitz++ 张量计算的示例
/* ****************************************************************************
* matmult.cpp     Blitz++ tensor notation example
*****************************************************************************
* This example illustrates the tensor-like notation provided by Blitz++.
*/

#include < blitz / array.h >
#include < iostream >

using namespace blitz;

int main()
{
     // Create two 4x4 arrays.  We want them to look like matrices, so
     // we'll make the valid index range 1..4 (rather than 0..3 which is
     // the default).

    Range r( 1 , 4 );
    Array < float , 2 > A(r,r), B(r,r);

     // The first will be a Hilbert matrix:
     //
     // a   =   1
     //   ij   -----
     //        i+j-1
     //
     // Blitz++ provides a set of types { firstIndex, secondIndex,  }
     // which act as placeholders for indices.  These can be used directly
     // in expressions.  For example, we can fill out the A matrix like this:

    firstIndex i;     // Placeholder for the first index
    secondIndex j;    // Placeholder for the second index

    A = 1.0 / (i + j - 1 );

    cout << " A = " << A << endl;

     // A = 4 x 4
     //          1       0.5  0.333333      0.25
     //        0.5  0.333333      0.25       0.2
     //   0.333333      0.25       0.2  0.166667
     //       0.25       0.2  0.166667  0.142857

     // Now the A matrix has each element equal to a_ij = 1/(i+j-1).

     // The matrix B will be the permutation matrix
     //
     // [ 0 0 0 1 ]
     // [ 0 0 1 0 ]
     // [ 0 1 0 0 ]
     // [ 1 0 0 0 ]
     //
     // Here are two ways of filling out B:

    B = (i == ( 5 - j));          // Using an equation -- a bit cryptic

    cout << " B = " << B << endl;

     // B = 4 x 4
     //          0         0         0         1
     //          0         0         1         0
     //          0         1         0         0
     //          1         0         0         0

    B = 0 , 0 , 0 , 1 ,            // Using an initializer list
         0 , 0 , 1 , 0 ,
         0 , 1 , 0 , 0 ,
         1 , 0 , 0 , 0 ;

    cout << " B = " << B << endl;

     // Now some examples of tensor-like notation.

    Array < float , 3 > C(r,r,r);   // A three-dimensional array: 1..4, 1..4, 1..4

    thirdIndex k;              // Placeholder for the third index

     // This expression will set
     //
     // c    = a   * b
     //   ijk    ik    kj

//    C = A(i,k) * B(k,j);
   cout << " C = " << C << endl;

     // In real tensor notation, the repeated k index would imply a
     // contraction (or summation) along k.  In Blitz++, you must explicitly
     // indicate contractions using the sum(expr, index) function:

    Array < float , 2 > D(r,r);
    D = sum(A(i,k) * B(k,j), k); // 指标收缩, 计算矩阵积

     // The above expression computes the matrix product of A and B.

    cout << " D = " << D << endl;

     // D = 4 x 4
     //       0.25  0.333333       0.5         1
     //        0.2      0.25  0.333333       0.5
     //   0.166667       0.2      0.25  0.333333
     //   0.142857  0.166667       0.2      0.25

     // Indices like i,j,k can be used in any order in an expression.
     // For example, the following computes a kronecker product of A and B,
     // but permutes the indices along the way:

    Array < float , 4 > E(r,r,r,r);     // A four-dimensional array
    fourthIndex l;                 // Placeholder for the fourth index

    E = A(l,j) * B(k,i); // 指标轮换
// cout << "E = " << E << endl;

     // Now let's fill out a two-dimensional array with a radially symmetric
     // decaying sinusoid.

     int N = 64 ;                    // Size of array: N x N
    Array < float , 2 > F(N,N);
     float midpoint = (N - 1 ) / 2 .;
     int cycles = 3 ;
     float omega = 2.0 * M_PI * cycles / double (N);
     float tau = - 10.0 / N;

    F = cos(omega * sqrt(pow2(i - midpoint) + pow2(j - midpoint)))
         * exp(tau * sqrt(pow2(i - midpoint) + pow2(j - midpoint)));

// cout << "F = " << F << endl;

     return 0 ;
}
// 输出
A = 4 x 4 [          1         0.5    0.333333        0.25           0.5    0.333333        0.25         0.2      0.333333        0.25         0.2    0.166667          0.25         0.2    0.166667    0.142857 ]

B = 4 x 4
[          0           0           0           1
           0           0           1           0
           0           1           0           0
           1           0           0           0 ]

B = 4 x 4
[          0           0           0           1
           0           0           1           0
           0           1           0           0
           1           0           0           0 ]

D = 4 x 4
[       0.25    0.333333         0.5           1
         0.2        0.25    0.333333         0.5
    0.166667         0.2        0.25    0.333333
    0.142857    0.166667         0.2        0.25 ]

杨粼波 2006-07-01 13:24 发表评论

Blitz++ 计算二阶导数

杨粼波 — Sat, 01 Jul 2006 05:23:00 GMT

// 整理 by RobinKin

#include < blitz / vector.h >

using namespace blitz;

int main()
{
     // In this example, the function cos(x)^2 and its second derivative
     // 2 (sin(x)^2 - cos(x)^2) are sampled over the range [0,1).
     // The second derivative is approximated numerically using a
     // [ 1 -2  1 ] mask, and the approximation error is computed.

/* cos(x)^2  的二阶导数是2 (sin(x)^2 - cos(x)^2)

下面在[0,1) 的范围中，以delta为步长，用[ 1 -2  1 ] 的方法计算二阶导数

看看和精确值的误差
*/

     const int numSamples = 100 ;               // Number of samples
     double delta = 1 . / numSamples;           // Spacing of samples
    Range R( 0 , numSamples - 1 );               // Index set of the vector

     // Sample the function y = cos(x)^2 over [0,1)
     //
     // An object of type Range can be treated as a vector, and used
     // as a term in vector expressions.
     //
     // The initialization for y (below) will be translated via expression
     // templates into something of the flavour
     //
     // for (unsigned i=0; i < 99; ++i)
     // {
     //      double _t1 = cos(i * delta);
     //      y[i] = _t1 * _t1;
     // }

    Vector < double > y = sqr(cos(R * delta));

     // Sample the exact second derivative
    Vector < double > y2exact = 2.0 * (sqr(sin(R * delta)) - sqr(cos(R * delta)));

     // Approximate the 2nd derivative using a [ 1 -2  1 ] mask
     // We can only apply this mask to the elements 1 .. 98, since
     // we need one element on either side to apply the mask.
    Range I( 1 ,numSamples - 2 );
    Vector < double > y2(numSamples);

    y2(I) = (y(I - 1 ) - 2 * y(I) + y(I + 1 )) / (delta * delta);

     // The above difference equation will be transformed into
     // something along the lines of
     //
     // double _t2 = delta*delta;
     // for (int i=1; i < 99; ++i)
     //      y2[i] = (y[i-1] - 2 * y[i] + y[i+1]) / _t2;

     // Now calculate the root mean square approximation error:

     double error = sqrt(mean(sqr(y2(I) - y2exact(I))));

     // Display a few elements from the vectors.
     // This range constructor means elements 1 to 91 in increments
     // of 15.
    Range displayRange( 1 , 91 , 15 );

    cout << " Exact derivative: " << y2exact(displayRange) << endl
          << " Approximation:    " << y2(Range(displayRange)) << endl
          << " RMS Error:        " << error << endl;

     return 0 ;
}

Output:

Exact derivative:[     - 1.9996    - 1.89847    - 1.62776    - 1.21164 - 0.687291 - 0.1015495
   ]
Approximation:   [    - 1.99953    - 1.89841     - 1.6277     - 1.2116 - 0.687269 - 0.1015468
   ]
RMS Error:        4.24826e-05

杨粼波 2006-07-01 13:23 发表评论