faq.texi

c++经典教材 Blitz++ v0.8

@section Questions about installation
@cindex FAQ

@cindex CRC error in .tar.gz
@cindex invalid compressed data

@faq{I downloaded Blitz++, but when I try to gunzip it, I get
``invalid compressed data--crc error''}

You forgot to set binary download mode in ftp.  Do so with
the ``binary'' command.

@cindex `Array' undeclared

@faq{The compiler complains that there is no Array class, even though I've
included @code{<blitz.h>}.}

You need to have the line:

@example
using namespace blitz;
@end example

after including @code{<blitz.h>}.

@cindex gcc memory hog
@cindex memory hog, gcc
@cindex out of virtual memory, gcc
@cindex virtual memory problems, gcc

@faq{I can't use gcc on my elderly PC because it requires @w{45--150@dmn{Mb}}
to compile with Blitz++}

Unfortunately this is true.  If this problem is ever fixed, it
will be by the gcc developers, so my best suggestion is to post
a bug report to the gcc-bugs list.  

@cindex external symbol relocation, Solaris

@faq{I am using gcc under Solaris, and I get errors about 
``relocation against external symbol''}

This problem can be fixed by installing the gnu linker and
binutils.  Peter Nordlund found that by using  @code{gnu-binutils-2.9.1},
this problem disappeared.  You can read a detailed 
discussion at
@uref{http://oonumerics.org/blitz/support/blitz-support/archive/0029.html}.

@cindex symbol too long, Solaris as

@faq{I am using gcc under Solaris, and the assembler gives
me an error that a symbol is too long.}

This problem can also be fixed by installing the gnu linker and
binutils.  See the above question.

@cindex templates with C linkage, DECcxx

@faq{DECcxx reports problems about ``templates with C linkage''}

This problem was caused by a problem in some versions of DECcxx's
@file{math.h} header: XOPEN_SOURCE_EXTENDED was causing an
@code{extern "C" @{ ... @}} section to have no closing brace.
There is a kludge which is included in recent versions of
Blitz++.

@cindex template instantiation resulted in an unexpected...

@faq{On some platforms (especially SGI) the testsuite program
@code{minsumpow} fails with the error: @code{Template instantiation resulted
in an unexpected function type of...}}

This is a known bug in the older versions of the EDG front end,
which many C++ compilers use.  There is no known fix.
Most of Blitz++ will work, but you won't be able to use
some array reductions.

@section Questions about Blitz++ functionality

@cindex eigenvector decomposition
@cindex solving linear systems
@cindex matrix inversion
@cindex linear algebra

@faq{For my problem, I need SVD, FFTs, QMRES, PLU, QR, ....}

Blitz++ does not currently provide any of these.  However, there are
numerous C++ and C packages out there which do, and it is easy to move data
back and forth between Blitz++ and other libraries.  See these terms in the
index: creating an array from pre-existing data, @code{data()},
@code{stride()}, @code{extent()}, @code{fortranArray}.  For a list of other
numerical C++ libraries, see the Object Oriented Numerics Page at
@uref{http://oonumerics.org/oon/}.

@cindex Python

@faq{Can Blitz++ be interfaced with Python?}

Phil Austin has done so successfully.  See a description of his setup in 
@uref{http://oonumerics.org/blitz/support/blitz-support/archive/0053.html}.

@cindex image processing
Also see Harry Zuzan's Python/Blitz image processing example code
at @uref{http://www.stat.duke.edu/~hz/blitz_py/index.html}.

@cindex out of memory
@cindex handling out of memory
@cindex new handler
@findex set_new_handler()
@findex bad_alloc

@faq{If I try to allocate an array which is too big, my program just crashes
or goes into an infinite loop.  Is there some way I can handle this more
elegantly?}

Blitz++ uses @code{new} to allocate memory for arrays.  In theory, your
compiler should be throwing a @code{bad_alloc} exception when you run out of
memory.  If it does, you can use a @code{try/catch} block to handle the out of
memory exception.  If your compiler does not throw @code{bad_alloc}, you can
install your own new handler to handle out of memory.

Here is an excerpt from the ISO/ANSI C++ standard which describes the
behaviour of @code{new}:

@itemize @bullet

@item  Executes a loop: Within the loop, the function first attempts to
allocate the requested storage. Whether the attempt involves a call to the
Standard C library function malloc is unspecified. 

@item  Returns a pointer to the allocated storage if the attempt is
successful. Otherwise, if the last argument to @code{set_new_handler()} was
a null pointer, throw @code{bad_alloc}. 

@item  Otherwise, the function calls the current @code{new_handler}
(lib.new.handler). If the called function returns, the loop repeats. 

@item  The loop terminates when an attempt to allocate the requested storage
is successful or when a called new_handler function does not return. 

@end itemize

You can use @code{set_new_handler} to create a new handler which
will issue an error message or throw an exception.  For
example:

@example 
void my_new_handler()
@{
cerr << "Out of memory" << endl;
cerr.flush();
abort();
@}

...

// First line in main():
set_new_handler(my_new_handler);
@end example 


@cindex passing arrays by value
@cindex constness problems

@faq{When I pass arrays by value, the function which receives
them can modify the array data.  Why?}

It's a result of reference-counting. You have to think of array objects as
being ``handles'' to underlying arrays. The function doesn't receive a copy of
the array data, but rather a copy of the handle.  The alternative would be
to copy the array data when passing by value, which would be grossly
inefficient.

@cindex @code{<<} operator, bitshift
@cindex operator @code{<<}, bitshift
@cindex operator @code{>>}, bitshift
@cindex @code{>>} operator, bitshift
@cindex bitshift operators

@faq{Why can't I use e.g.@: @code{A >> 3} to do bitshifting on arrays?}

The operators @code{<<} and @code{>>} are used for input/ouput of arrays.
It would cause problems with the expression templates implementation to also
use them for bitshifting.  However, it is easy enough to define your own
bitshifting function -- see @ref{User et}.

@cindex matrix multiply

@faq{When I write @code{TinyMatrix * TinyVector} I get an error.}

Try @code{product(d2,d1)}.  This works for matrix-matrix and matrix-vector
products.