The deal.II news page
Author: the deal.II authors <authors@dealii.org>
Keywords: deal.II

## Changes between versions 3.1.0 and 3.2.0

This is a quite extensive list of changes made between versions 3.1.0 and 3.2.0 of deal.II. It is subdivided into changes made to the three sub-libraries base, lac, and deal.II, as well as changes to the general infrastructure, documentation, etc.

### General

1. New: example program step-11.
   (WB 2001/09/17)

2. New: example program step-10.
   (WB, RH 2001/09/12)

3. New: the `./configure` script now also recognizes Compaq's cxx compiler. The library now also compiles cleanly with this compiler.
   (WB 2001/07/06)

4. Changed: The libraries are no more linked using the C++ compilation flags, but rather using LDFLAGS. Some compilers object to compilation flags on the linker line.
   (WB 2001/05/23)

5. Changed: If in multithreaded mode, the ACE library is now automatically added to the `$(LIBS)` Makefile variable. There is no need anymore for a special clause in your Makefile.
   (WB 2001/05/23)

6. New: the `./configure` script now also recognizes the Intel ICC compiler that was released for Linux lately. The library now also compiles cleanly with this compiler.
   (WB 2001/05/22)

7. Fixed: the program that generated HTML from the example programs was broken on some platforms for reasons beyond our knowledge. This is now fixed.
   (Roger Young, WB 2001/03/22)

8. Improved: libraries are now all in a subdirectory lib in the deal.II home directory. It is now easy to make this directory a link to put the libraries on a faster disk.
   (GK 2001/03/14)

9. New Design of `FiniteElements` and `Mappings`

   New: The finite element classes have been redesigned from scratch to allow also elements that depend on the actual cell shape, like Raviart-Thomas, BDM or edge elements. We have implemented continuous Lagrange elements up to degree four and discontinous Lagrange elements up to degree 10. They can be easily extended to higher degree.

   Furthermore we have totally reimplemented the mapping between unit and real cell. In future we won't be restricted to Q1 mapping any more, but we will have Qp mappings of arbitrary degree p. Presently implemented are mappings up to degree 10 in 2d, and degree three in 3d. This allows to approximate curved boundaries not only by straight lines (linear approximation) but also by quadratic, cubic, etc approximation. The finite elements will be able to be combined with arbitrary mappings. So in future we can use subparametric, iso- as well as superparametric elements.

   The new implementation uses a totally new structure of communication between `FEValues`, the `FiniteElements` and the `Mappings`. Despite of this, the new structure will almost not be 'visible' to the user of deal.II as we tried to retain the interface to the user (mainly that of `FEValues`) as far as possible.

   Together with this new design comes a reduction of 25000(!) lines of deal.II code. This elimination mainly affected code that previously was machine generated (e.g. by maple). In view of almost unchanged execution times of applications, the faster compilation and additional functionality constitutes a significant improvement of deal.II. Results produced by the new code match those of the old design up to machine precision.
   (RH & GK 2001/03/13)

10. New: There is now some support to include and use routines from the Harwell Subroutine Library.
    (WB 2001/01/30)

11. New: The `./configure` script now checks for the existence of a Fortran 77 compiler, and sets its path, some compiler flags and the libraries to be linked in when mixing C++ and F77 in some variables in the file `common/Make.global_options`.
    (WB 2000/12/30)

### base

1. New: Color function `DataOutBase::EpsFlags::reverse_grey_scale_color_function`.
   (WB 2001/08/24)

2. New: Function `QProjector::project_to_child` generates quadrature formulae which act on the area which a child would occupy.
   (WB 2001/08/23)

3. Changed: The examples classes in the base directory are now moved into a namespace `Functions` of their own. This improves encapsulation, but also keeps the documentation of these functions together, as they were previously scrambled all over the screen in the documentation page of the base library.
   (WB 2001/07/18)

4. New: classes `FourierSineFunction` and `FourierCosineFunction`, resembling one mode of a Fourier decomposition. Classes `FourierSineSum` and `FourierCosineSum`, resembling sums of such modes of a Fourier decomposition.
   (WB 2001/07/18)

5. New: class `vector2d` was introduced in analogy to STL class `vector`. The bew class provides a two-dimensional array and replaces the use of `FullMatrix` in the base library.
   (GK 2001/05/21)

6. Improved: `JobIdentifier`::`operator()` includes host name if supported by the operating system
   (GK 2001/05/17)

7. New: There is now a new `AutoDerivativeFunction` class that automatically computes the gradient of a function by employing numerical difference quotients. This only, if the user function does not provide the gradient function himself. This class can replace the `Function` class as base class for user defined `Function` classes.
   This new class can be used if the user only implements the `value` function but wants to call also the `gradient` functions.
   (RH 2001/05/15)

8. New: The `Quadrature` class now has a constructor that only accepts quadrature points and sets the weights to invalid values.
   (GK 2001/04/26)

9. New: The function `Logstream`::`get_prefix` allows access to the prefix string used for log-files.
   (GK 2001/04/26)

10. New: There is now a global function `trace` that computes the trace of a tensor of rank 2.
    (WB 2001/04/12)

11. New: The `Threads` now has a barrier class in order to synchronise multiple threads. In multithreaded mode, this is an alias to the `ACE_Barrier` class of the ACE library, if deal.II is not configured for multithreading, then the class is a dummy class that does nothing.
    (WB 2001/03/19)

12. New: We now support the output format of the Visualization Toolkit (Vtk) from the `DataOutBase` class and all derived classes.
    (WB 2001/03/19)

13. New: The class `TensorProductPolynomials<dim>` performs the tensor product of 1d polynomials, computes its values, its first and second derivatives. If `n` polynomials are given to the constructor of this class, it constructs `ndim` tensor product polynomials.
    (RH 2001/03/14)

14. New: `LagrangeEquidistant` is a new class derived from `Polynomial` providing the 1d Lagrange interpolation of degree `n` of `n+1` equidistant support points in `[0,1]`. It is implemented up to degree 10. This class is used for the implementation of the continuous and discontinuous Lagrange elements.
    (RH 2001/03/14)

15. New: The new `Polynomial` class can be used as base class for all 1d polynomials. It stores the coefficients of the polynomial and uses the Horner scheme to evaluate values and all derivates.
    (RH 2001/03/14)

16. New: function `contract` for two arguments of `Tensor<1,dim>`
    (GK 2001/03/05)

17. New: `Logstream`::`log_time_differences (bool)` makes `Logstream` print the time since the last log line instead of accumulated time since program start.
    (GK 2001/03/05)

18. Fix: `Logstream`::`pop()` does not perform anything on empty stacks.
    (GK 2001/03/05)

19. Changed: Sort the quadrature points of each `Quadrature<1>` in ascending order. This actually changed the order of the points of only `QGauss4` and `QGauss5`.
    (Ralf Hartmann 2001/01/22)

20. New: function `contract` for two arguments of `Tensor<1,dim>`
    (GK 2001/01/15)

### lac

1. New: Function `FullMatrix::symmetrize()`.
   (WB 2001/09/20)

2. Improved: the stopping criterion of `SolverBicgstab` without computing the exact residual is implemented
   (GK 2001/09/11)

3. New: The `FullMatrix` class now has a function `operator*=`, which simply scales the matrix.
   (WB 2001/09/02)

4. New: Function `BlockSparseMatrix::el()`, just like `SparseMatrix::el()`.
   (WB 2001/08/21)

5. New: There is now a class `MatrixOut` which can be used to convert a matrix into a graphical output, for example in order to see visually that a matrix is diagonally dominant or not.
   (WB 2001/08/21)

6. Changed: Base class `Solver` and all `Preconditioner` classes are now derived from `Subscriptor`. Class `PreconditionLACSolver` now uses smartpointers to the given solver and preconditioner objects. You will, therefore, have to derive your own preconditioners and solvers from `Subscriptor` if you want to use it with `PreconditionLACSolver`.
   (WB 2001/08/16)

7. New: Classes `Vector` and `BlockVector` now have member functions `operator*=` which scale the vectors by a constant factor. These functions are aliases for the `scale` member functions except that they return a reference to themselves.
   (WB 2001/08/14)

8. New: There is now a function `FullMatrix::precondition_Jacobi`. The `PreconditionJacobi` class is therefore now also applicable with the full matrix class.
   (WB 2001/08/11)

9. New: The `Vector` and `BlockVector` classes can now be initialized using a new constructor that takes two iterators that denote a range of elements which are to be copied.
   (WB 2001/08/08)

10. Changed: The `SolverCG` class now saves the initial matrix vector product if the initial value of the solution is vector is zero, as it is common practice to use this is starting vector.
    (WB 2001/06/25)

11. New: `SparsityPattern::reinit` no more throws an error if the given maximal row lengths are all zero.
    (WB 2001/06/25)

12. New: Class `CompressedBlockSparsityPattern` may be used as an intermediate form of the `BlockSparsityPattern`.
    (WB 2001/06/23)

13. New: Class `CompressedSparsityPattern` may be used as an intermediate form of the `SparsityPattern` class if memory requirements are tight during construction of the sparsity pattern.
    (WB 2001/06/22)

14. New: There are now functions `SparsityPattern::copy_from` and `SparseMatrix::copy_from` that can be used to construct sparsity patterns and matrix at once, i.e. without setting up a sparsity pattern element by element, possibly after using a way too large value for the maximal row length, then calling `SparsityPattern::compress` etc.
    (WB 2001/05/07)

15. New: `BlockIndices::block_size` returns the size of a specified block.
    (WB 2001/05/07)

16. New: There is now a (private) function `SparsityPattern::optimized_lower_bound` that is used as an optimized replacement for `std::lower_bound` for searching in the column number arrays. It unrolls small loops and it also seems that the compiler is able to optimized it better due to eliminated template parameters, making it about twice as fast as the standard implementation. In effect, it also speeds up the SSOR preconditioner that spent about one third of its time in that function by approximately 15 per cent.
    (WB 2001/04/25)

17. New: The `FilteredMatrix` class is a replacement for the `MatrixTools::apply_boundary_values` function for cases where you would like to solve several times with the same matrix, either for different right hand sides, or for different boundary values.
    (WB 2001/04/27)

18. New: There is now a function `Vector`::`scale(Vector)` that scales each element of the vector by the corresponding element of the argument.
    (WB 2001/04/23)

19. Changed: Solver functions `solve` return void now. If the solver has not converged within the maximum number of iterations or encounters a breakdown, it throws an exception of type `SolverControl`::`NoConvergence` instead of returning a special value.
    (GK 2001/03/29)

20. New: The functions `FullMatrix`::`mmult` and `Tmmult` now have an additional `adding` argument. If this flag is `true`, the matrix-matrix product is added to the resulting matrix; if `false`, the resulting matrix is set to (overwritten by) the matrix-matrix product. The latter is the behaviour these functions had before. Hence the default value is set to be `false` to ensure backward compatibility.
    (RH 2001/03/29)

21. New: class `SchurMatrix` implements a Schur complement for block matrices. It provides matrix-vector multiplication suitable for iterative methods as well as pre- and post-processing of right hand side and slution, respectively.
    (GK 2001/03/22)

22. Removed: The explicite instantiations of `SparseMatrix<long double>` are removed as a prerelease of gcc3.0 fails to compile it. A user of `SparseMatrix<long double>` needs now to include `lac/include/lac/sparse_matrix.templates.h` into his source file and to use an appropriate compiler, e.g. gcc2.95.2 or a future version of gcc3.0 (that will then hopefully be fixed).
    (RH 2001/03/14)

23. New: class `BlockMatrixArray<MATRIX>` implements a block matrix based on an array of matrix pointers. Since this array may be incomplete, no direct access to entries is allowed. Matrix blocks may be scaled and transposed.
    (GK 2001/02/13)

24. New: There is now some support to include and use routines from the Harwell Subroutine Library, and support classes `SparseDirectMA27` and `SparseDirectMA47` for the sparse direct solvers MA27 and MA47.
    (WB 2001/01/30)

### deal.II

1. New: Class `MappingQ1Eulerian` implementing an Eulerian mapping.
   (Michael Stadler 2001/09/24)

2. New: `VectorTools::create_boundary_right_hand_side` integrates boundary forces for inhomogeneous Neumann boundary values.
   (WB 2001/09/13)

3. New: `DoFTools::make_flux_sparsity_pattern` now exists also for 1d.
   (WB 2001/09/03)

4. New: There are now two functions `FETools::hierarchic_to_lexicographic_numbering` and `FETools::lexicographic_to_hierarchic_numbering` which map the hierarchical numbering used in continuous finite element classes to a lexicographical numbering and back.
   (WB 2001/08/31)

5. New: `ConstraintMatrix::close` now simply returns instead of throwing an exception, if the matrix was already closed.
   (WB 2001/08/30)

6. New: Member function `ConstraintMatrix::is_identity_constrained`.
   (WB 2001/08/29)

7. Fixed: in a rather rare case, some work was done twice in the `KellyErrorEstimator` class when in multithread mode. This is now fixed.
   (WB 2001/08/24)

8. New: There is now a class `GridTools` which provides algorithms working on triangulations. At present, it offers a function computing the diameter of a triangulation.
   (WB 2001/08/16)

9. Changed: The `MatrixCreator` and `MatrixTools` class have lost their template arguments. Rather, the individual functions now are templated on their own, so the compiler can pick out the correct space dimension on its own.
   (WB 2001/08/15)

10. Extended: `ConstraintMatrix::merge` can now handle arguments which further constrain the present object.
    (WB 2001/07/30)

11. New: Implement `DoFTools::make_sparsity_pattern`, `DoFTools::make_boundary_sparsity_pattern`, and `ConstraintMatrix::condense` to work on the `CompressedSparsityPattern` and `CompressedBlockSparsityPattern` and classes.
    (WB 2001/06/22)

12. New: `FE*Values::get_quadrature` returns a reference to the quadrature formula used by a FEValues object.
    (WB 2001/06/21)

13. New: `DoFTools::compute_intergrid_transfer_representation` is a function that generates a matrix representation that can be used to transfer data from one grid to one component of the fields on another, finer, grid.
    (WB 2001/05/24)

14. Changed: the `GeometryInfo` class has been reverted from a general template that calculates the values of its member variables by recursion/induction to a set of explicitely specialized classes. This seemed necessary since most compilers objected to the old implementation as the declaration of the values of the class required knowledge of the elements of the class with one lower dimension which was, however, only being declared at present except for 1d. Also, allocating space for variables was difficult as that would mean declaring specializations after their first use. The new (and very old) implementation is entirely compatible to the previous one.
    (WB 2001/05/23)

15. Changed: the classes that denote flags to the `TimeStepBase_Tria` class have been move from local classes to a namespace of their own, names `TimeStepBase_Tria_Flags`.
    (WB 2001/05/23)

16. Fixed: due to a bug in gcc, the compiler did not check that we did not use the set of given boundary indicators to the `DoFTools::extract_boundary_dofs` function in 1d. That set was therefore ignored. This is now fixed.
    (WB 2001/05/18)

17. Changed: the flags which are given to the `GridOut` class to modify the appearance of the output have been moved from local classes of the `GridOut` class to a namespace names `GridOutFlags` and have lost the trailing `Flags` part in their name. This change was necessary as C++ does not allow explicit specialization of member classes; the previous use in the library was only accepted by GCC as an extension.
    (WB 2001/05/17)

18. New: The functions `DoFTools::map_dof_to_boundary_indices`, `DoFTools::make_boundary_sparsity_pattern`, `DoFHandler::n_boundary_dofs`, `DoFHandler::max_couplings_between_boundary_dofs`, and `VectorTools::project_boundary_values`, are now also implemented in 1d.
    (WB 2001/04/29)

19. New: There are now functions `DoFTools`::`map_dofs_to_support_points` and `DoFTools`::`map_support_points_to_dofs` that generate a map between DoF indices and the support points of these DoFs, and the other way round.
    (WB 2001/04/24)

20. New: Implement the `VectorTools::interpolate_boundary_values` a second time, this time taking a `FunctionMap` object as do all the other functions of this type.
    (WB 2001/04/23)

21. Fixed: The vertex numbers written by the `GridOut`::`write_ucd_faces` function are now also 1-based. This, to be consistent with the vertex numbers given by the `GridOut`::`write_ucd` function.
    (RH 2001/04/20)

22. Extended: the `DerivativeApproximation` class now also works in 3d, as the spectral norm of a symmetric 3x3 matrix can now be computed.
    (Roger Young 2001/04/12)

23. Fixed: the `DoFRenumbering`::`Cuthill_McKee` function did not work correctly when giving the `reversed_numbering` flag (off-by-one indexing). This is now fixed.
    (Oliver Rheinbach 2001/04/12)

24. Changed: A `typedef FunctionMap` was declared in at least four places previously (in classes `DoFHandler`, `MatrixTools`, `VectorTools`, and `KellyErrorEstimator`). It is now unified in one place and is called `FunctionMap<dim>`::`type` (it is a local typedef in a class called `FunctionMap`). This type is defined in the file `dofs/function_map.h`.
    (WB 2001/04/09)

25. Fixed: When using Neuman boundary functions in the `KellyErrorEstimator` class, it was assumed that the function object had `Function`::`vector_value` overloaded, even in the scalar case. We now use `Function`::`value` instead.
    (WB 2001/04/09)

26. New: The various `MatrixCreator`::`create_*_matrix` functions are now using multiple threads to do their work, if the library is configured to use multithreading.
    (WB 2001/04/08)

27. New: The following functions are extended to work on arbitrary mappings:
    The static `create_mass_matrix`, `create_boundary_mass_matrix` and `create_laplace_matrix` member functions of the class `MatrixCreator`,
    the static `project` and `project_boundary_values` member functions of the class `VectorTools`,
    the two versions of the static `estimate` member functions of the class `KellyErrorEstimator`,
    and the static `approximate_gradient` and `approximate_second_derivative` member functions of the class `DerivativeApproximation`.

    All these functions now take a `Mapping` object as additional argument.
    For backward compatibility there exist second versions of each of these functions that still don't have a `Mapping` argument. These functions implicitely use a mapping of the class `MappingQ1`.
    (RH 2001/04/05)

28. Removed: Along with the redesign of the `FiniteElement` and the `Mapping` classes the `FiniteElement`::`get_local_mass_matrix` function is now removed. This was necessary as the local mass matrix depends not only on the considered `FiniteElement` but also on the mapping between the unit to the real cell. Hence this function cannot be a member function of a `FiniteElement` any more.

    As a consequence also the `MatrixCreator`::`create_mass_matrix` function with two arguments is removed, as it relied on the `get_local_mass_matrix` function. If in future the user wants to create a mass matrix he needs to use one of the remaining `MatrixCreator`::`create_mass_matrix` functions that require an appropriate `Quadrature` as argument.
    (RH 2001/04/04)

29. New/Fixed: Now there exists a new `Triangulation`::`ExcMultiplySetLineInfoOfLine` exception, that is thrown if the `SubCellData` that is given to `Triangulation`::`create_triangulation`, multiply includes the line info of a specific line. Before the fix the wrong `ExcInteriorLineCantBeBoundary` exception was thrown.
    (RH 2001/04/03)

30. Fixed: Missing `ucd` is now added to the list of supported output formats returned by `GridOut`::`get_output_format_names`.
    (RH 2001/04/03)

31. New/fixed: In some obscure corner cases, the detection logic in `DataOut_DoFData::add_data_vector` would not have been able to detect whether something is a DoF data vector or a vector of cell data, and in some equally rare cases this would also have made a difference. This is now fixed by adding another argument to the function telling it either to automatically detect the vector type (default) or to assume that it has a certain type (for these corner cases).
    (WB 2001/03/30)

32. Removed: the `ProblemBase` class, which has been deprecated since before the release of deal.II 3.0, has finally been removed. The same applies for the classes `Assembler`, `Equation`, `MassMatrix`, and `LaplaceMatrix`.
    (WB 2001/03/27)

33. New: There is now a class `MappingC1` that implements a continuously differentiable C1 mapping of the boundary by using a cubic mapping with continuous derivatives at cell boundaries. The class presently only implements something for 2d and 1d (where it does nothing).
    (WB 2001/03/27)

34. New: The static `interpolate`, `create_right_hand_side`, `interpolate_boundary_values`, `integrate_difference` and `compute_mean_value` member functions of the class `VectorTools` are extended to work on arbitrary mappings. All these functions now take a `Mapping` object as additional argument.
    For backward compatibility there exist second versions of each of these functions that still don't have a `Mapping` argument. These functions implicitely use a mapping of the class `MappingQ1`.
    (RH 2001/03/27)

35. New: `Boundary` and derived classes now have a function `get_normals_at_vertices` that returns a multiple of the normal vector to the boundary at the vertices of a given face. This is used in the construction of C1 mappings of the boundary.
    (WB 2001/03/23)

36. New: The new function `PersistentTriangulation<dim>`::`restore(unsigned int)` allows to restore the triangulation step by step.
    New: Now there exists a function `PersistentTriangulation<dim>`::`clear_flags` to allow to re-`read_flags` without the need of clearing the triangulation in advance.
    New: The new function `PersistentTriangulation<dim>`::`n_refinement_steps` returns the number of refinement steps stored in `refine_flags`.
    (RH 2001/03/20)

37. New: `GridGenerator`::`hyper_rectangle` creates coordinate-parallel rectangles in arbitrary dimension.
    (GK 2001/03/16)

38. Changed: The syntax of the `FiniteElement<dim>`::`get_unit_support_points` function is changed; it returns a reference to the vector of points in lieu of taking this vector as argument. The unit support points are now computed by the constructor of the `FiniteElement` and not on each `FiniteElement<dim>`::`get_unit_support_points` function call as before.
    (WB 2001/03/14)

39. Removed: The function `FiniteElement<dim>`::`get_support_points` is removed as the `FiniteElement` cannot know the position of the support points by itself. This is because the support points depend on the unit support points (known to the `FiniteElement` class) but they also depend on the mapping. In future the support points can be computed using a `FEValues` object initialized with the `Mapping` and a `Quadrature` that uses the unit support points as quadrature points.
    (RH 2001/03/14)

40. New: The class `Boundary` has two new functions `get_intermediate_points_on_line` and `get_intermediate_points_on_quad` that needs to be implemented in derived classes only if `GridOut` is used with `MappingQ` of degree `p>2`.
    (RH 2001/03/14)

41. New: The functions `GridOut::write_gnuplot` and `GridOut::write_eps` now take a pointer to a `Mapping` object as additional argument. This allows to write grids in 2d whereby cells with a curved boundary are transformed by the given `Mapping` class. The default mapping is `MappingQ1`. Note, that the grids do not show the `original' domain with boundaries described by the `Boundary` classes but the discretized domain whose boundary cells are transformed using the given mapping.

    There are also a new `GnuplotFlags::n_boundary_face_points` and `EpsFlags::n_boundary_face_points` variables to set the number of additional points written to represent the curved boundary faces.
    (RH 2001/03/14)

42. New: The constructor of the `FEValues` and `FE(Sub)FaceValues` classes now take a reference of a `Mapping` object as additional argument. This is the new possibility to combine a `FiniteElement` with an arbitrary `Mapping`, see also New FE and Mapping Design.

    For backward compatibility there still exists a constructor of `FEValues` without a `Mapping` argument that uses a `MappingQ1` by default.
    (RH 2001/03/14)

43. Changed: We now unconditionally include `deal.II/include/grid/tria_accessor.templates.h` (which containts some inline functions for triangulation accessor classes) into `deal.II/include/grid/tria_accessor.h` to work around a problem with gcc3.0 which does not place a copy of these functions into the library. Previously we only included the file in optimized mode.
    (RH 2001/03/14)

44. New: The class `GridReordering::Cell` has now a copy constructor to work around a bug in a gcc3.0 snapshot.
    (RH, WB 2001/03/14)

45. Changed: when refining a hexahedron in 3d, the rules by which the new vertices at the centers of the faces and at the center of the cell are placed, are changed. They are changed in a way as to minimize the distortion of the resulting cells from the optimal shape and to make them look as much alike as possible to generate a smoother grid.
    (WB 2001/03/02)

46. Fix: the `DoFTools`::`compute_intergrid_constraints` function took memory quadratic in the number of degrees of freedom. This is now reduced to linear behaviour, with a constant that depends on the number of levels by which the two grids differ.
    (WB 2001/02/26)

47. Fix: in the triangulation, the `straight_boundary` variable, which is a reference, was assigned the address of a temporary object. It is unclear how this could have worked for three years, but it apparently did...
    (WB 2001/02/26)

48. New: The `DoFTools` class now has a function `count_dofs_per_component` that counts the number of degrees of freedom in each of the components of the finite element, i.e. how many degrees of freedom there are on the global mesh for each variable (field).
    (WB 2001/02/22)

49. New: The `CellAccessor` class now has a function `has_boundary_lines` that mostly has the same semantics that `at_boundary` has, but also covers the case that a hexahedron in 3d may be at the boundary only by one line, rather than by a whole face. In that case, `at_boundary` reports false, while `has_boundary_lines` reports true.
    (WB 2001/02/21)

50. New: There is now a function `ConstraintMatrix`::`merge` that merges the constraints represented by two constraint matrices into one object.
    (WB 2001/01/31)

Last update $Date: 2013-07-23 09:49:55 -0400 (Tue, 23 Jul 2013) $