mummy(1) [debian man page]

MUMMY(1)							   User Commands							  MUMMY(1)

NAME

       mummy - generate C# wrappers from C++ code.

SYNOPSIS

       mummy [options] files...

DESCRIPTION

       mummy is a command line executable that generates C# wrappers from gccxml output. A C# class is generated to wrap the wrappable class named
       in the gccxml output. Settings to control the wrapping are given inline directly in the class header file or in the MummySettings.xml input
       file.

       mummy version 1.0.2 (revision 599)

       Command line options:

       --csharp-file opt
	      C# output file. Default value is 'ClassName.cs' in the current directory.

       --csharp-unit-test-file opt
	      C# output file. Default value is 'ClassNameUnitTest.cs' in the current directory.

       --export-layer-file opt
	      C++ output file. Default value is 'ClassNameEL.cxx' in the current directory.

       --gccxml-file opt
	      Input file (output of gccxml) describing class to be wrapped. Required.

       --help Display (this) detailed help information.

       --settings-file opt
	      Input file describing mummy configuration settings, including the set of wrapped classes.  Required.

       --suppress-warnings opt opt ...
	      Space separated list of warning numbers to suppress.

       --verbose
	      Overwhelm me with output, I don't have enough reading material... ;)

       --version
	      Display the program version.

AUTHORS

       This manual page was written by Mathieu Malaterre <malat@debian.org>, for the Debian project (and may be used by others).

SEE ALSO

       cableidx(1), gccxml(1).

mummy version 1.0.2 (revision 599)				   December 2011							  MUMMY(1)

solver(2rheolef)						    rheolef-6.1 						  solver(2rheolef)

NAME

       solver - direct or interative solver interface

DESCRIPTION

	The class implements a matrix factorization:
	LU factorization for an unsymmetric matrix and
	Choleski fatorisation for a symmetric one.

	Let a be a square invertible matrix in
	csr format (see csr(2)).

	       csr<Float> a;

	We get the factorization by:

	       solver<Float> sa (a);

	Each call to the direct solver for a*x = b writes either:

	       vec<Float> x = sa.solve(b);

	When the matrix is modified in a computation loop but
	conserves its sparsity pattern, an efficient re-factorization
	writes:

	       sa.update_values (new_a);
	       x = sa.solve(b);

	This approach skip the long step of the symbolic factization step.

ITERATIVE SOLVER

	The factorization can also be incomplete, i.e. a pseudo-inverse,
	suitable for preconditionning iterative methods.
	In that case, the sa.solve(b) call runs a conjugate gradient
	when the matrix is symmetric, or a generalized minimum residual
	algorithm when the matrix is unsymmetric.

AUTOMATIC CHOICE AND CUSTOMIZATION

	The symmetry of the matrix is tested via the a.is_symmetric() property
	(see csr(2)) while the choice between direct or iterative solver
	is switched from the a.pattern_dimension() value. When the pattern
	is 3D, an iterative method is faster and less memory consuming.
	Otherwhise, for 1D or 2D problems, the direct method is prefered.

	These default choices can be supersetted by using explicit options:

	       solver_option_type opt;
	       opt.iterative = true;
	       solver<Float> sa (a, opt);

	See the solver.h header for the complete list of available options.

IMPLEMENTATION NOTE

	The implementation bases on the pastix library.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class solver_basic : public smart_pointer<solver_rep<T,M> > {
       public:
       // typedefs:

	 typedef solver_rep<T,M>    rep;
	 typedef smart_pointer<rep> base;

       // allocator:

	 solver_basic ();
	 explicit solver_basic (const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
	 void update_values (const csr<T,M>& a);

       // accessors:

	 vec<T,M> trans_solve (const vec<T,M>& b) const;
	 vec<T,M> solve       (const vec<T,M>& b) const;
       };
       // factorizations:
       template <class T, class M>
       solver_basic<T,M> ldlt(const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
       template <class T, class M>
       solver_basic<T,M> lu  (const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
       template <class T, class M>
       solver_basic<T,M> ic0 (const csr<T,M>& a, const solver_option_type& opt = solver_option_type());
       template <class T, class M>
       solver_basic<T,M> ilu0(const csr<T,M>& a, const solver_option_type& opt = solver_option_type());

       typedef solver_basic<Float> solver;

SEE ALSO

       csr(2), csr(2)

rheolef-6.1							    rheolef-6.1 						  solver(2rheolef)