slayoo
commented
8 years ago Probably somehow relevant - some time ago (on the occasion of the 2015 C++now conference) I've prepared a list of minimal code samples that make use of Blitz++ features that we've found in our team missing in other libraries/languages. It would be great to hear if those features are indeed unique or not (I guess they should be somehow obtainable with eigen::Tensor???).
1. overloadable OO index arithmetics (useful for implementing fractional indices)
#include <blitz/array.h>
struct hlf_t {} h;
blitz::Range operator+( const blitz::Range &i, hlf_t &)
{ return i; }
blitz::Range operator-( const blitz::Range &i, hlf_t &)
{ return i-1; }
blitz::Range operator^( const blitz::Range &r, hlf_t &n)
{
return blitz::Range(
(r - n).first(),
(r + n).last()
);
}
int main()
{
blitz::Range i(0,10);
blitz::Array<float, 1> psi(i), phi(i^h);
psi(i) = ( phi(i-h) + phi(i+h) ) / 2;
}2. multi-dimensional indexing with single objects (e.g. easy to return index permutation from a function)
#include <blitz/array.h>
int main()
{
blitz::Range i(0,9), j(0,9), k(0,9);
blitz::Array<int, 3> psi(i,j,k);
std::cerr << psi(i,j,k);
blitz::RectDomain<3> ijk({i,j,k});
std::cerr << psi(ijk);
} 3. tensor notation
#include <blitz/array.h>
int main()
{
blitz::Array<float,2> psi(4,4);
{
using namespace blitz::tensor;
psi = sqrt(i*i + j*j);
}
std::cout << psi;
} 4. array-valued functions (with reference counting, optionally thread-safe)
//#define BZ_THREADSAFE // to enable access locks for ref counting
#include <blitz/array.h>
enum { opt_sin, opt_cos };
template <int opt, typename T>
auto func(T &a, typename std::enable_if<opt == opt_sin>::type* = 0)
{
return safeToReturn(pow(sin(a), 2)); // keeps ref count
}
template <int opt, typename T>
auto func(T &a, typename std::enable_if<(opt == opt_cos)>::type* = 0)
{
return safeToReturn(pow(cos(a), 2)); // keeps ref count
}
int main()
{
blitz::Array<float, 1> psi(1000);
{
using namespace blitz::tensor;
psi = i / 20.;
}
psi = func<opt_sin>(psi) + func<opt_cos>(psi);
std::cout << psi;
} 5. elemental functors
#include <blitz/array.h>
struct func
{
float a = .25, b = .1;
float operator()(float x) const
{
return a * x + b;
}
// to make it accept Blitz arrays as arguments
BZ_DECLARE_FUNCTOR(func);
};
int main()
{
blitz::Array<float, 1> psi(10), x(10);
x = blitz::tensor::i;
psi = func()(x);
}6. ternary operator & reductions (with lazy/delayed evaluation!)
#include <blitz/array.h>
int main()
{
blitz::Array<float, 2> psi(5,5);
{
using namespace blitz::tensor;
psi = sqrt((i*i) + (j*j));
}
// ternary operator
psi = where(psi>3, 0, psi);
// partial reduction
{
using namespace blitz::tensor;
auto xpr = sum(psi, j); // delayed eval!
}
} Comments welcome...
burnpanck
citibeth
wolfv
Thank you all for your input on this issue. After much consideration, I think that Blitz++ is worth keeping around. Even in 2016, it remains unique in concept and execution.
Blitz++ claims to do one thing only: provide multi-dimensional arrays for C++, similar to those in Fortran 90, Python/Numpy, and APL. Notice that Fortran 2008 has this feature but nothing like STL, and is widely used for scientific computing. It is clear that multi-dim arrays are essential in a way that STL is not. Of course, a system offering both is even more useful...
It is therefore disappointing that such arrays are still not part of the C++ standard. This is after 15 years of work on Blitz++, boost::multi_array, etc. Without any standard, different libraries use different classes for the same data structure, limiting compatibility between them. Interoperability is cumbersome, and often requires unnecessary copying of multi-dimensional data structures (assuming there's enough RAM).
Many of us confuse multi-dimensional arrays with matrices and vectors. Matrices and vectors are essential to scientific computing, and may be the most common type of arrays used. However, they do not take the place of the more general multi-dimensional array. This becomes clear to anyone attempting to read 5-dimensional data out of a HDF/NetCDF file. In an ideal world, matrix and vector classes (and operations) would be built upon a foundation of rank 1 and 2 arrays, thereby enhancing compatibility between different linear algebra libraries.
By offering only multi-dimensional arrays, Blitz++ provides a foundation upon which linear algebra and other libraries may be built. The fact that none have taken advantage of this foundation seems to be a missed opportunity. However... until/unless something better comes along, I believe we should continue to support Blitz++.
Why is Blitz++ so good?
In my review, I found only two other serious efforts to offer multi-dimensional arrays for C++. Both have potentially serious problems:
"I don't know what the language of the year 2000 will look like, but I know it will be called Fortran." -- Tony Hoare [CarHoare], apparently on a card distributed during the 1982 AFIPS National Computing Conference.
A number of other libraries exist that provide specialized matrix and vector classes. I do not need to mention them here because they don't provide multi-dimensional arrays.
I propose the following roadmap for the continued viability of Blitz++:
`. We get volunteers. Please contact me if you are interested in any of the tasks listed below.
We then start working on Blitz 2.0, which will make use of features in C++11 and beyond. C++98 users can continue to use Blitz 1.0. Updates might include: