http://www-users.informatik.rwth-aachen.de/~roberts/meshgeneration.html

Mesh Generation & Grid Generation on the Web

The aim of this document is to provide information on mesh and grid generation: people working in the field, research groups, books and conferences. It is maintained by Robert Schneiders.

Mesh generation is an interdisciplinary area, and people from different departments are working on it: Mathematicians, computer scientists, engineers from many disciplines. Despite the fact that surprisingly many people are active in the field, often there are few contacts between researchers. The aim of this page is to improve communication between research groups and to help people to get an overview of the field.

The page is organized as follows:

<!-- -->

People and research groups: Info on meshing research at universities, companies, government labs etc. List of people: A directory of people working on mesh generation. Latest news: What's up in mesh generation. Software: A list of programs, both public domain and commercial. Conferences: Information on conferences, summerschools, short courses etc. Literature: Books, reviews, online sources and course materials. Open positions: Career opportunities for people with background in mesh generation. Information on related topics: Pages with information on CFD, scientific computing, computational geometry and other fields related to mesh generation.

<!-- --> Service for frequent readers: You can find all entries, sorted by time of insertion, here (there is also an archive page). <!-- Click here to see the latest updates (there is also an archive page). -->

Research on mesh generation is abundant, and I don't claim to give a complete overview. In order make this page a useful service for the mesh generation community, I need help from other people. So if you are interested in getting put on the list, or if you have any comments or hints on other sources of information on mesh generation in the net, please send me an email (robert.schneiders@arcor.de).

A valuable source of information is the Meshing Research Corner, a comprehensive database with literature on mesh generation. It is maintained by Steve Owen.

a general finite element environment;mathematica

http://library.wolfram.com/infocenter/TechNotes/6635/

The Mathematica application package AceFEM is a general finite element environment designed to solve multi-physics and multi-field problems. Using Mathematica, the program provides both extensive symbolic capabilities and the numeric efficiency of a commercial finite element environment.

AceFEM consists of two components. The main module performs tasks such as processing user-input data, mesh generation, control of solution procedures, and graphic post-processing of results. A fully integrated second module handles numerically intensive operations such as evaluation and assembly of finite element quantities, solution of linear systems of equations, contact search procedures, and more.

finite element; matlab

Kwon, Y. W. and Bang, H. The Finite Element Method Using MATLAB. Boca Raton, FL: CRC Press, 1996

Matlab .m Unstructured Mesh Generation (Mesh2d v2.3)

Unstructured Mesh Generation (Mesh2d v2.3)

MESH2D is a toolbox for the generation and manipulation of unstructured triangular meshes in MATLAB. High quality meshes can be generated automatically for user defined geometries. These meshes are suitable for subsequent FEM or FVM analysis. MESH2D will automatically adapt the element size to ensure that the geometry is adequately resolved, allowing very complex geometries to be meshed with no additional user input. User defined size functions are also available, allowing the user to control mesh resolution if desired. MESH2D is based on an iterative continuous smoothing method, and generally results in very high quality meshes with no small angles and smooth element size variations. WHAT'S NEW IN v2.3? MESH2D v2.3 allows connected polygons to be meshed, with a compatible mesh generated along internal boundaries. MESH 2D v2.3 should also produce meshes with a higher mean element quality in most cases. - MESH2D can produce large scale meshes, with meshes incorporating over 500,000 elements produced based on satellite coastline data. - MESH2D allows fully user defined size functions, giving the user full control over mesh resolution if desired. A template for boundary layer regions is also included. - MESH2D includes functions for uniform and non-uniform mesh refinement, allowing existing meshes to be refined without costly re-triangulation. - MESH2D includes functions to assemble the connectivity information necessary for FE or FV methods. Tested on MATLAB 6.5, 7.0, R2006b and R2007a. DEMO FUNCTIONS: Please use the following functions to launch MESH2D demos: - meshdemo(); - mesh_collection(n); - facedemo(n); MESH2D is (always!) under development, so any problems or suggestions are welcome via email. MESH2D is distributed under the GNU GPL.

Ref.

http://www.mathworks.de/matlabcentral/fileexchange/loadFile.do?objectId=10307&objectType=file

matlab .m DISTMESH A Simple Mesh Generator in MATLAB

HomePage Per-Olof Persson

http://www.mit.edu/~persson/software.html

Software

Meshing:

• DistMesh - A Simple Mesh Generator in MATLAB

Educational MATLAB codes:

• Tridiagonal Eigenvalues in MATLAB - Interface to LAPACK routines for computing eigenvalues of tridiagonal matrices and singular values of bidiagonal matrices
• Level Set Demo - Simple MATLAB scripts for illustration of explicit/implicit interface tracking, reinitialization, and the fast marching method (undocumented, but see presentations for slides and notes).
• fempoisson.m - Solves the Poisson equation on an unstructured grid (square in this example but easy to change) using linear finite elements. Good start to learn about implementation of FEM.
• poiunit.m - Fourier solution of Poisson's equation on the unit line, square, or cube. Good for verification of Poisson solvers, but slow if many Fourier terms are used (high accuracy).
• laplacefft.m - Solve the Laplace equation on a rectangular domain using the FFT. Supports Dirichlet or Dirichlet/Neumann conditions. Contains the following short functions for discrete Sine and Cosine transforms:
  
  • dst.m - Discrete Sine Transform DST-I
  • idst.m - Inverse Discrete Sine Transform IDST-I
  • dct.m - Discrete Cosine Transform DCT-I
  • idct.m - Inverse Discrete Cosine Transform DCT-I
  
  
• Implementation of Finite Element-Based Navier-Stokes Solver

--------------------------end HomePage

http://www-math.mit.edu/~persson/mesh/gallery_images.html

3-D meshes, the left plots show surface meshes and the right plots show cross sections.



-----------

http://people.scs.fsu.edu/~burkardt/m_src/distmesh/distmesh.html

DISTMESH is a MATLAB library which generates and manipulates unstructured meshes in 2D, 3D and general ND. The code is relatively simple, and the user is able to define a variety of geometric shapes, and desired mesh densities.

DISTMESH can be a very quick and flexible means of computing a set of points in a region. However, keep in mind the following flaws:

• Especially if you are have specified some fixed points which must appear in the mesh, it is possible for DISTMESH to return multiple instances of the same point. For finite element applications, in particular, this can result in catastrophe. The program TABLE_MERGE can fix this.
• The nodes produced by DISTMESH are not ordered or sorted in any way whatsoever.
• Because the nodes are not ordered in any way, the triangular elements produced by DISTMESH will typically contain nodes with widely ranging indices. For finite element applications, this can result in a system matrix with an unnecessarily outrageous bandwidth. The program TRIANGULATION_RCM can fix this, after the fact.
• The triangles produced by DISTMESH are not necessarily oriented; they are just as likely to have positive or negative orientation. Some finite element programs insist that all triangles have positive orientation. The program TRIANGULATION_ORIENT can fix this, after the fact.
• When DISTMESH is trying to approximate a boundary, particularly a long straight boundary, it is possible for several points that really belong on the boundary to be slightly out of line. This means that they will be used to form a triangle, of very small area, and terrible conditioning. This can result in perplexing problems near the boundary.
• Because DISTMESH uses tolerances, it is possible for some nodes to lie outside the boundary of the region; it is possible for some triangles on the boundary to lie partially outside the region; it is possible for triangles that lie partly on the boundary, but entirely within the region, to be deleted, leaving a triangular hole.
• Once you have the mesh, you may want to know which nodes lie on the boundary. You'll want this information, for instance, if you need to impose boundary conditions on such nodes. You can get a list of the boundary nodes using the program TRIANGULATION_BOUNDARY_NODES.

Usage:

[ p, t ] = distmesh_2d ( fd, fh, h, box, iteration_max, fixed );

takes:

• fd, the name of a distance function defining the region;
• fh, the name of a mesh density function;
• h, the nominal mesh spacing;
• box, defining a box that contains the region;
• iteration_max, which limits the number of iterations;
• fixed, a list of points which must be included in the mesh.

and returns a triangulation defined by:

• p, a list of node coordinates;
• t, a list of node indices forming triangles;

Related Data and Programs:

DIST_PLOT is a MATLAB program which creates a color contour plot of the distance functions that are used by DISTMESH.

DISTMESH_3D is a MATLAB program which is a subset of the DISTMESH routines, exclusively for 3D problems.

TABLE_IO is a MATLAB library which reads and writes files using the TABLE format; these routines are used by DISTMESH when creating some output files.

TABLE_MERGE is a FORTRAN90 program which removes duplicate points from a TABLE file; it can also remove points that are "close" to each other;

TEST_TRIANGULATION is a MATLAB library which defines some test regions for triangulation.

TRIANGLE is a C program which triangulates a region.

TRIANGULATION_BOUNDARY_NODES is a MATLAB program which reads data defining a triangulation and determines which nodes lie on the boundary.

TRIANGULATION_DISPLAY_OPEN_GL is a C++ program which reads files defining a triangulation and displays an image using Open GL.

TRIANGULATION_L2Q is a MATLAB program which reads data defining a linear triangulation and adds midpoint nodes to create a quadratic triangulation.

TRIANGULATION_MASK is a MATLAB program which is compiled with a user routine that defines a region; it then reads data defining a triangulation and removes all triangles that are outside the region. This is one way to clean up an unconstrained Delaunay triangulation of a nonconvex region.

TRIANGULATION_ORDER3 is a data directory which discusses order 3 triangulations; The node and triangle files output by DISTMESH are an example of such triangulations.

TRIANGULATION_ORIENT is a MATLAB program which reads data defining a triangulation, makes sure that every triangle has positive orientation, and if not, writes a corrected triangle file.

TRIANGULATION_PLOT is a MATLAB program which plots a triangulation.

TRIANGULATION_RCM is a MATLAB program which reads data defining a triangulation, and uses the Reverse Cuthill McKee algorithm to reorder the nodes so as the reduce the bandwidth of the corresponding adjacency matrix. This can be very helpful for cases where the data is to be handled by a frontal technique, or treated as a banded linear system.

TRIANGULATION_REFINE is a MATLAB program which reads data defining a triangulation and creates a refinement of the triangulation by subdividing each triangle.

Author:

DISTMESH is Copyright (C) 2004 Per-Olof Persson.

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

If you use DISTMESH in any program or publication, please acknowledge its authors by citing the reference.

Reference:

1. http://math.mit.edu/~persson/
   Per-Olof Persson's web site.
2. Per-Olof Persson and Gilbert Strang,
   A Simple Mesh Generator in MATLAB,
   SIAM Review,
   Volume 46, Number 2, June 2004, pages 329-345,
   Available online at ../../pdf/persson_distmesh.pdf

Tar File:

A GZIP'ed TAR file of the contents of this directory is available. This is only done as a convenience for users who want ALL the files, and don't want to download them individually. This is not a convenience for me, so don't be surprised if the tar file is somewhat out of date.

• distmesh_m_src.tar.csh the commands used to create the GZIP'ed TAR file.
• distmesh_m_src.tar.gz the GZIP'ed TAR file.

Source Code:

• boundedges.m finds the surface edges in a triangular mesh.
• circumcenter.m computes the circumcenters of the triangles that form a triangulation of a set of nodes.
• dcircle.m returns the signed distance of one or more points to a circle.
• ddiff.m returns the signed distance of one or more points to a region defined as the set difference of two regions.
• dexpr.m returns the signed distance of one or more points to a region defined by a general symbolic expression.
• dintersect.m returns the signed distance to a region that is the intersection of two regions.
• distmesh_2d.m computes a mesh of a given 2D region.
• distmesh_nd.m computes a mesh of a given ND region.
• dmatrix.m returns the signed distance to a region by interpolation of known distance values on a Cartesian grid.
• dpoly.m returns the signed distance of one or more points to a polygon.
• drectangle.m returns the signed distance of one or more points to a rectangle.
• drectangle0.m, returns the signed distance of one or more points to a rectangle.
• dsegment.cpp (C++ file), a version of the algorithm for the signed distance of one or more points to a set of line segments, for use with a non-Windows version of MATLAB. This file must be compiled, and the corresponding MEX file must be available to define the MATLAB/C++ interface.
• dsegment.dll (binary file), a Windows DLL file, returns the signed distance of one or more points to a set of line segments.
• dsegment.m a pure MATLAB version of DSEGMENT, which returns the signed distance of one or more points to a set of line segments. This routine will be significantly slower than the MEXGLX or DLL versions.
• dsegment.mexglx (binary file), used on non-Windows machines to allow MATLAB to calculate the DSEGMENT algorithm (distance to a line segment) by calling a compiled C++ routine (dsegment.cpp).
• dsphere.m returns the signed distance of one or more points to a sphere.
• dunion.m returns the signed distance to a region that is the union of two regions.
• hmatrix.m computes the mesh size function by interpolation from values specified on a Cartesian grid.
• huniform.m computes a uniform mesh size function.
• meshdemo_nd.m demonstrates the use of the program for higher dimensional problems.
• post_2d.m performs postprocessing for output from DISTMESH_2D.
• protate.m rotates a set of points by a given angle.
• pshift.m shifts a set of points by a given increment.
• r8_epsilon.m returns the R8 arithmetic precision.
• simp_plot_2d.m displays a plot of the triangles that form a mesh in 2D.
• simp_plot_2d_demo.m reads and displays the node and triangle data for each problem.
• simp_plot_3d.m displays a plot of the tetrahedrons that form a mesh in 3D.
• simpqual.m computes the simplex quality of the mesh.
• simpvol.m computes the volume of a simplex.
• surftri.m finds the surface triangles in a tetrahedral mesh.
• timestamp.m prints the current YMDHMS time as a timestamp.
• timestring.m returns the current YMDHMS time as a string.
• triangulation_order3_plot.m writes a PostScript file containing an image of the mesh.
• uniformity.m computes the uniformity of the mesh.

Routines to read and write data to files (borrowed from TABLE_IO) include:

• dtable_data_read.m reads the data of a double precision table file.
• dtable_data_write.m writes the data of a double precision table file.
• dtable_header_read.m reads the header of a double precision table file.
• dtable_header_write.m writes the header of a double precision table file.
• dtable_read.m reads a double precision table file.
• dtable_write.m writes a double precision table file.
• file_column_count.m counts the number of columns in a table file.
• file_row_count.m counts the number of rows in a table file.
• itable_data_read.m reads the data of an integer table file.
• itable_data_write.m writes the data of an integer table file.
• itable_header_read.m reads the header of an integer table file.
• itable_header_write.m writes the header of an integer table file.
• itable_read.m reads an integer table file.
• itable_write.m writes an integer table file.
• s_len_trim.m returns the length of a string to the last nonblank.
• s_word_count.m counts the number of "words" in a string.

----------

DistMesh Function Reference

Back

---

boundedges

Syntax:	e=boundedges(p,t)
Description:	Find all the boundary edges e in triangular mesh p,t.
Comments:	Useful for implementation of boundary conditions for PDE solvers. See surftri for 3-D version.

circumcenter

Syntax:	[pc,r]=circumcenter(p,t)
Description:	Compute the circumcenters pc and the circumradii r for all triangles in the mesh p,t.
Comments:	Not vectorized.

dcircle

Syntax:	d=dcircle(p,xc,yc,r)
Description:	Compute signed distance function for circle centered at xc,yc with radius r.
Comments:

ddiff

Syntax:	d=ddiff(d1,d2)
Description:	Compute signed distance function for set difference of two regions described by signed distance functions d1,d2.
Comments:	Not exactly the true signed distance function for the difference, for example around corners.

dellipse

Syntax:	d=dellipse(p,axes)
Description:	Compute distance from points p to the ellipse centered at the origin with axes=[a,b].
Comments:	C++ code, uses LAPACK for eigenvalue problem.

dellipsoid

Syntax:	d=dellipsoid(p,axes)
Description:	Compute distance from points p to the ellipsoid centered at the origin with axes=[a,b,c].
Comments:	C++ code, uses LAPACK for eigenvalue problem.

dexpr

Syntax:	d=dexpr(p,fin,nit,alpha)
Description:	Compute signed distance function for general implicit expression fin. The parameters nit and alpha have the default values 20 and 0.1.
Comments:	Requires the Symbolic Toolbox, although easy to rewrite to accept derivatives of fin as inputs. The performance is poor, a simple C implementation makes a big difference.

dintersect

Syntax:	d=dintersect(d1,d2)
Description:	Compute signed distance function for set intersection of two regions described by signed distance functions d1,d2.
Comments:	Not exactly the true signed distance function for the intersection, for example around corners.

distmesh2d

Syntax:	[p,t]=distmesh2d(fd,fh,h0,bbox,pfix,fparams)
Description:	2-D Mesh Generator. See other documentation for details on usage.
Comments:

distmeshnd

Syntax:	[p,t]=distmeshnd(fd,fh,h0,bbox,pfix,fparams)
Description:	3-D Mesh Generator. See other documentation for details on usage.
Comments:

dmatrix

Syntax:	d=dmatrix(p,xx,yy,dd)
Description:	Compute signed distance function by interpolation of the values dd on the Cartesian grid xx,yy.
Comments:	xx,yy can be created with meshgrid.

dmatrix3d

Syntax:	d=dmatrix3d(p,xx,yy,zz,dd)
Description:	Compute signed distance function by interpolation of the values dd on the Cartesian grid xx,yy,zz.
Comments:	xx,yy,zz can be created with ndgrid.

dpoly

Syntax:	d=dpoly(p,pv)
Description:	Compute signed distance function for polygon with vertices pv.
Comments:	Uses dsegment and inpolygon. It is usually good to provide pv as fix points to distmesh2d.

drectangle

Syntax:	d=drectangle(p,x1,x2,y1,y2)
Description:	Compute signed distance function for rectangle with corners (x1,y1), (x2,y1), (x1,y2), (x2,y2).
Comments:	Incorrect distance to the four corners, see drectangle0 for a true distance function.

drectangle0

Syntax:	d=drectangle0(p,x1,x2,y1,y2)
Description:	Compute signed distance function for rectangle with corners (x1,y1), (x2,y1), (x1,y2), (x2,y2).
Comments:	See drectangle for simpler version ignoring corners.

dsegment

Syntax:	ds=dsegment(p,pv)
Description:	Compute distance from points p to the line segments in pv.
Comments:	C++ code, used by dpoly.

dsphere

Syntax:	d=dsphere(p,xc,yc,zc,r)
Description:	Compute signed distance function for sphere centered at xc,yc,zc with radius r.
Comments:

dunion

Syntax:	d=dunion(d1,d2)
Description:	Compute signed distance function for set union of two regions described by signed distance functions d1,d2.
Comments:	Not exactly the true signed distance function for the union, for example around corners.

fixmesh

Syntax:	[p,t]=fixmesh(p,t)
Description:	Remove duplicated and unused nodes from p and update t correspondingly. Also make all elements orientations equal.
Comments:

hmatrix

Syntax:	h=hmatrix(p,xx,yy,dd,hh)
Description:	Compute mesh size function by interpolation of the values hh on the Cartesian grid xx,yy.
Comments:	xx,yy can be created with meshgrid. The parameter dd is not used, but included to get a syntax consistent with dmatrix.

hmatrix3d

Syntax:	h=hmatrix3d(p,xx,yy,zz,dd,hh)
Description:	Compute mesh size function by interpolation of the values hh on the Cartesian grid xx,yy,zz.
Comments:	xx,yy,zz can be created with ndgrid. The parameter dd is not used, but included to get a syntax consistent with dmatrix.

huniform

Syntax:	h=huniform(p)
Description:	Implements the trivial uniform mesh size function h=1.
Comments:

meshdemo2d

Syntax:	meshdemo2d
Description:	Demonstration of distmesh2d.
Comments:

meshdemond

Syntax:	meshdemond
Description:	Demonstration of distmeshnd.
Comments:

mkt2t

Syntax:	[t2t,t2n]=mkt2t(t)
Description:	Compute element connectivities from element indices.
Comments:

protate

Syntax:	p=protate(p,phi)
Description:	Rotate points p the angle phi around origin.
Comments:

pshift

Syntax:	p=pshift(p,x0,y0)
Description:	Move points p by (x0,y0).
Comments:

simpplot

Syntax:	simpplot(p,t,expr,bcol,icol)
Description:	Plot 2-D or 3-D mesh p,t. The parameters expr, bcol, icol are only used in 3-D and they have default values.
Comments:

simpqual

Syntax:	q=simpqual(p,t,type)
Description:	Compute qualities of triangular or tetrahedral elements in the mesh p,t. If type==1 (default) the inradius/outradius expression is used. If type==2 a slightly different expression is used.
Comments:

simpvol

Syntax:	v=simpvol(p,t)
Description:	Compute the signed volumes of the simplex elements in the mesh p,t.
Comments:

surftri

Syntax:	tri=surftri(p,t)
Description:	Find all the surface triangles tri in tetrahedral mesh p,t.
Comments:	Used by simpplot. Also useful for implementation of boundary conditions for PDE solvers. See boundedges for 2-D version.

uniformity

Syntax:	u=uniformity(p,t,fh,fparams)
Description:	Computes "uniformity measure", that is, how close the element sizes in the mesh p,t are to the desired mesh size function fh.
Comments:

------------

Examples and Tests:

MESHDEMO_2D runs all the 2D tests:

• meshdemo_2d.m demonstrates the use of the program for 2D problems.
• meshdemo_2d_output.txt the output from a run of MESHDEMO_2D.

P01 is the circle:

• p01_demo.m runs the problem.
• p01_fd.m the signed distance function.
• p01_fh.m a uniform mesh density function.
• p01_mesh.png a PNG image of the mesh.
• p01_nodes.txt the mesh nodes of the problem.
• p01_triangles.txt the mesh triangles of the problem.

P02 is the circle with a hole:

• p02_demo.m runs the problem.
• p02_fd.m the signed distance function.
• p02_fh.m a uniform mesh density function.
• p02_mesh.png a PNG image of the mesh.
• p02_nodes.txt the mesh nodes of the problem.
• p02_triangles.txt the mesh triangles of the problem.

P03 is the square with a hole:

• p03_demo.m runs the problem.
• p03_fd.m the signed distance function.
• p03_fh.m a uniform mesh density function.
• p03_mesh.png a PNG image of the mesh.
• p03_nodes.txt the mesh nodes of the problem.
• p03_triangles.txt the mesh triangles of the problem.

P04 is the hexagon with hexagonal hole:

• p04_demo.m runs the problem.
• p04_fd.m the signed distance function.
• p04_fh.m a uniform mesh density function.
• p04_mesh.png a PNG image of the mesh.
• p04_nodes.txt the mesh nodes of the problem.
• p04_triangles.txt the mesh triangles of the problem.

P05 is the horn:

• p05_demo.m runs the problem.
• p05_fd.m the signed distance function.
• p05_fh.m a nonuniform mesh density function.
• p05_mesh.png a PNG image of the mesh.
• p05_nodes.txt the mesh nodes of the problem.
• p05_triangles.txt the mesh triangles of the problem.

P06 is the superellipse:

• p06_demo.m runs the problem.
• p06_fd.m the signed distance function.
• p06_fh.m a nonuniform mesh density function.
• p06_mesh.png a PNG image of the mesh.
• p06_nodes.txt the mesh nodes of the problem.
• p06_triangles.txt the mesh triangles of the problem.

P07 is the bicycle seat:

• p07_demo.m runs the problem.
• p07_fd.m the signed distance function.
• p07_fh.m a uniform mesh density function.
• p07_mesh.png a PNG image of the mesh.
• p07_nodes.txt the mesh nodes of the problem.
• p07_triangles.txt the mesh triangles of the problem.

P08 is the holey pie slice:

• p08_demo.m runs the problem.
• p08_fd.m the signed distance function.
• p08_fh.m a nonuniform mesh density function.
• p08_mesh.png, a PNG image of the mesh.
• p08_nodes.txt the mesh nodes of the problem.
• p08_triangles.txt the mesh triangles of the problem.

P09 is Jeff Borggaard's square with two hexagonal holes:

• p09_demo.m runs the problem.
• p09_fd.m the signed distance function.
• p09_fh.m a uniform mesh density function.
• p09_mesh.png a PNG image of the mesh.
• p09_nodes.txt the mesh nodes of the problem.
• p09_triangles.txt the mesh triangles of the problem.

P10 is the unit square:

• p10_demo.m runs the problem.
• p10_fd.m the signed distance function.
• p10_fh.m a uniform mesh density function.
• p10_mesh.png a PNG image of the mesh.
• p10_nodes.txt the mesh nodes of the problem.
• p10_triangles.txt the mesh triangles of the problem.

P11 is the L-shaped region:

• p11_demo.m runs the problem.
• p11_fd.m the signed distance function.
• p11_fh.m a uniform mesh density function.
• p11_mesh.png a PNG image of the mesh.
• p11_nodes.txt the mesh nodes of the problem.
• p11_triangles.txt the mesh triangles of the problem.

P12 is the John Shadid's H-shaped region:

• p12_demo.m runs the problem.
• p12_fd.m the signed distance function.
• p12_fh.m a uniform mesh density function.
• p12_mesh.png a PNG image of the mesh.
• p12_nodes.txt the mesh nodes of the problem.
• p12_triangles.txt the mesh triangles of the problem.

P13 is the Sandia fork:

• p13_demo.m runs the problem.
• p13_fd.m the signed distance function.
• p13_fh.m a uniform mesh density function.
• p13_mesh.png a PNG image of the mesh.
• p13_nodes.txt the mesh nodes of the problem.
• p13_triangles.txt the mesh triangles of the problem.

P14 is Marcus Garvie's Lake Alpha, with Beta Island:

• p14_demo.m runs the problem.
• p14_fd.m the signed distance function.
• p14_fh.m a nonuniform mesh density function.
• p14_mesh.png a PNG image of the mesh.
• p14_nodes.txt the mesh nodes of the problem.
• p14_triangles.txt the mesh triangles of the problem.

P15 is Sangbum Kim's forward step region:

• p15_demo.m runs the problem.
• p15_fd.m the signed distance function.
• p15_fh.m a nonuniform mesh density function.
• p15_mesh.png a PNG image of the mesh.
• p15_nodes.txt the mesh nodes of the problem.
• p15_triangles.txt the mesh triangles of the problem.

P16 is Kevin Pond's elbow, a quarter of a circular annulus:

• p16_demo.m runs the problem.
• p16_fd.m the signed distance function.
• p16_fh.m the mesh density function.
• p16_mesh.png a PNG image of the mesh.
• p16_nodes.txt the mesh nodes of the problem.
• p16_triangles.txt the mesh triangles of the problem.

P17 is a rectangular region with a Reuleaux triangle obstacle.

• p17_demo.m runs the problem.
• p17_fd.m the signed distance function.
• p17_fh.m the mesh density function.
• p17_mesh.png a PNG image of the mesh.
• p17_nodes.txt the mesh nodes of the problem.
• p17_triangles.txt the mesh triangles of the problem.

a starting point for building 3D surface meshes or true volumetric tetrahedral grids

"nanosecond history":

__________1987

Since William Lorensen and Harvey Cline’s publication of Marching Cubes: A High
Resolution 3D Surface Construction Algorithm in 1987 Marching Cubes has become the
defining algorithm for the creation of 3D surface meshes.

Yet despite the success of Marching Cubes the resulting mesh exhibits several weaknesses, including aliasing and terracing artifacts, less-than-optimal triangle quality, and large numbers of triangles.  A
multitude of techniques have been introduced to address these issues, including surface
smoothing and triangle decimation algorithms. Beyond reducing artifacts, smoothing
improves the effectiveness of triangle decimation algorithms and reduces errors during
finite element analysis. However, many smoothing techniques fail to eliminate terracing
because their local filter neighborhood does not encompass the width of the terrace.
Additionally, smoothing a mesh without consideration of the original data may smooth
away crucial fine details as well as mesh generation artifacts.

___________1998

In 1998 Sarah F. F. Gibson published Constrained Elastic Surface Nets: Generating
Smooth Surfaces from Binary Segmented Data. Her work attempts to preserve the fine
detail present in the original data by applying smoothing directly to the binary data and
introduces the concept of a constraint to limit the deviation of the smoothed data from the
original. Modified SurfaceNets attempts to apply Gibson’s SurfaceNet technique to the
problem of smoothing a Marching Cubes mesh. By defining SurfaceNet nodes on the
Marching Cubes mesh and constraining their movement to their Voronoi regions,
Modified SurfaceNets aims to reduce terracing while preserving the fine detail of the
original image.
-----------------------

see http://en.wikipedia.org/wiki/Marching_cubes

and see this present bog : http://stef2cnrs.wordpress.com

----------------------

This class of Surface Reconstruction methods is OK for immerged SURFACE and only for SURFACE.

If you want to generate not only surface models from your data but also to create true
volumetric tetrahedral grids suitable for advanced 3D finite-element simulations, then open your mind... Usually, these grids are constructed using a flexible advancing-front algorithm. Again, special care is taken to obtain meshes of high quality, i.e., tetrahedra with bad aspect ratio are avoided...

see a commercial software (with a quite good link with matlab): http://www.comsol.com/

----------------------

In biophotonics, we have this process:

1/produce your images (exactly a stack of 2D images)

2/perform many image cleaning and many img processes with or without informations from the other images in the stack (often it is only a process for each image with imageJ)

3/the final step is segmentation & binarisation also with or without informations from the other images in the stack

4/generation of surface ( a/isosurface for rendering; b/ 3D surface mesh)

5/generation true  3D volumetric tetrahedral grids suitable for advanced 3D finite-element simulations

6/a 4D solver with time

7/statistics and comparison between biology, medical and multiphysics data and 4D simulations

collection of routines MATLAB Source Codes

Ref.

http://people.scs.fsu.edu/~burkardt/m_src/m_src.html

------------

1. tri_mesh_display, a program which displays a surface in 3D described as a mesh of triangles;
2. tri_mesh_to_ply, a program which converts a TRI_MESH dataset to a dataset suitable for storage as a PLY file.

------------

MATLAB Source Codes

---

This is a collection of routines for use with MATLAB.

Available software includes:

1. args, a program which shows how to count and report command line arguments;
2. arpack, a library which computes eigenvalues and eigenvectors of large sparse matrices, accessible via the built-in EIGS command;
3. asa005 a library which evaluates the lower tail of the noncentral Student's T distribution; this is Applied Statistics Algorithm 5;
4. asa006 a library which computes the Cholesky factor of a positive definite symmetric matrix; this is Applied Statistics Algorithm 6;
5. asa007 a library which computes the inverse of a positive definite symmetric matrix; this is Applied Statistics Algorithm 7;
6. asa032 a library which evaluates the incomplete Gamma function; this is Applied Statistics Algorithm 32;
7. asa047 a library which minimizes a scalar function of several variables using the Nelder-Mead algorithm; this is Applied Statistics Algorithm 47;
8. asa058 a library which carries out clustering of data; this is Applied Statistics Algorithm 58;
9. asa063 a library which evaluates the incomplete Beta function; this is Applied Statistics Algorithm 63;
10. asa066 a library which computes the cumulative density function of the standard normal distribution; this is Applied Statistics Algorithm 66;
11. asa076 a library which evaluates Owen's T function; this is Applied Statistics Algorithm 76;
12. asa091, a library which computes the percentage points of the Chi-square distribution; this is Applied Statistics Algorithm 91;
13. asa103, a library which evaluates the digamma or psi function; this is Applied Statistics Algorithm 103;
14. asa109 a library which inverts the incomplete Beta function; this is Applied Statistics Algorithm 109;
15. asa111 a library which evaluates the percentage points of the normal distribution; this is Applied Statistics Algorithm 111;
16. asa113 a library which clusters data using the Banfield and Bassill transfer and swap algorithm; this is Applied Statistics Algorithm 113;
17. asa121, a library which evaluates the trigamma function; this is Applied Statistics Algorithm 121;
18. asa136 a library which clusters data using the Hartigan and Wong algorithm; this is Applied Statistics Algorithm 136;
19. asa144 a library which randomly generates tables with given row and column sums; this is Applied Statistics Algorithm 144;
20. asa147 a library which evaluates the incomplete Gamma function; this is Applied Statistics Algorithm 147;
21. asa152, a library which evaluates point and cumulative probabilities associated with the hypergeometric distribution; this is Applied Statistics Algorithm 152;
22. asa183, a library which implements the Wichman-Hill pseudorandom number generator; this is Applied Statistics Algorithm 183;
23. asa226 a library which evaluates the noncentral incomplete Beta function; this is Applied Statistics Algorithm 226;
24. asa239 a library which evaluates the incomplete Gamma function; this is Applied Statistics Algorithm 239;
25. asa241, a library which computes the inverse of the normal CDF; this is Applied Statistics Algorithm 241;
26. asa243 a library which evaluates the lower tail of the noncentral Student's T distribution; this is Applied Statistics Algorithm 243;
27. asa245 a library which evaluates the logarithm of the Gamma function; this is Applied Statistics Algorithm 245;
28. asa299, a library which computes the lattice points (integer coordinates) in an M-dimensional simplex; this is Applied Statistics Algorithm 299;
29. asa310 a library which evaluates the noncentral incomplete Beta function; this is Applied Statistics Algorithm 310;
30. beta_nc, a library which evaluates the CDF of the noncentral Beta distribution;
31. bezier_surface, a library which reads, writes, prints and manipulates the data that defines a Bezier surface;
32. bezier_surface_display, a program which displays a Bezier surface;
33. black_scholes, a library which implements some simple approaches to the Black-Scholes option valuation theory;
34. blas1, a library which implements the Basic Linear Algebra Subprograms, level 1;
35. blas1_c, a library which implements the Level 1 Basic Linear Algebra Subprograms, using single precision complex arithmetic;
36. blas1_d, a library which implements the Level 1 Basic Linear Algebra Subprograms, using double precision real arithmetic;
37. blas1_s, a library which implements the Level 1 Basic Linear Algebra Subprograms, using single precision real arithmetic;
38. blas1_z, a library which implements the Level 1 Basic Linear Algebra Subprograms, using double precision complex arithmetic;
39. box_plot, a program which displays a box plot of data that consists of pairs of integers;
40. brent a library which contains Richard Brent's routines for finding zeroes or minima of functions, without the use of derivative information.
41. cavity_flow_display, a library which displays a single velocity field solution for the driven cavity;
42. cavity_flow_movie, a library which animates the velocity solutions for the driven cavity;
43. cc_display, a program which displays the points used in a 2D Clenshaw-Curtis quadrature rule;
44. ccvt_box, a program which calculates a constrained CVT for points constrained to lie in a box, with some points moved to the boundary;
45. ccvt_reflect, a program which calculates a constrained CVT for points constrained to lie in a box, with some points "pushed" towards the boundary;
46. cg_lab_triangles, a collection of programs associated with a computer lab assignment on computational geometry and triangles;
47. chebyshev1_rule, a program which computes and writes out a Gauss-Chebyshev type 1 quadrature rule of given order.
48. chebyshev2_rule, a program which computes and writes out a Gauss-Chebyshev type 2 quadrature rule of given order.
49. chrpak, a library which manipulates characters and strings;
50. claw_pix, a library which visualizes the output of of the 1D version of CLAWPACK;
51. clawpack_plot, a library which visualizes the output of of CLAWPACK;
52. clenshaw_curtis, a library which implements Clenshaw Curtis and Fejer quadrature;
53. collatz, a library which computes and analyzes the Collatz sequence (or "hailstone" sequence or "3n+1 sequence");
54. contour_sequence, a program which creates images suitable for animation from a sequence of (X,Y,U(X,Y)) data files;
55. contour_sequence3, a program which creates images suitable for animation from one pair of X, Y files, and a sequence of U(X,Y) data files;
56. contour_sequence4, a program which creates images suitable for animation from one XY file and a sequence of U(X,Y) data files;
57. coordinate_search, a program which implements the coordinate search algorithm for the minimization of a scalar function of several variables.
58. cordic, a library which computes a few special functions using the CORDIC algorithm.
59. cvt, a library which computes an N-point Centroidal Voronoi Tesselation in M dimensions;
60. cvt_1d_nonuniform, a program which computes an N-point Centroidal Voronoi Tesselation in 1 dimension, under a nonuniform density, and plots the evolution of the locations of the generators during the iteration;
61. cvt_dataset a program which creates a CVT dataset;
62. cvt_demo, a program which interactively, graphically demonstrates a CVT calculation;
63. cvt_metric, a program which computes a CVT under a spatially varying metric;
64. cvt_movie, a program which creates an animation of the evolution of a CVT;
65. cvt_movie2, a program which creates a CVT movie;
66. cvt_movie3, a program which creates a CVT movie in a region of unusual shape;
67. cvt_movie4, a program which creates a CVT movie in a square, with a density function that drives points to the corners;
68. cvt_movie5, a program which repeats cvt_movie3, but with hexagonal grid initialization, fixed points, and boundary projection;
69. direction_arrows, a program which reads coordinate data from one file, velocity data from another file, and makes an arrow plot of the direction field.
70. direction_arrows_grid, a program which reads velocity data at "scattered" points, and makes a direction vector plot on a uniform grid of user-specified density.
71. direction_arrows_sequence, a program which reads a fixed coordinate file, and a sequence of velocity data files and makes a sequence of velocity direction arrow plots.
72. direction_arrows_sequence2, a program which reads a sequence of coordinate and velocity data and makes a sequence of velocity direction arrow plots.
73. direction_arrows2, a program which reads coordinate and velocity data from a single file and makes an arrow plot of the direction field.
74. dist_plot, a program which makes contour plots of the distance function, as defined and used in Persson and Strang's distmesh code;
75. distmesh, a library which carries out Persson and Strang's method of mesh generation;
76. distmesh_3d, a library which constitutes the 3D subset of Persson and Strang's distmesh code;
77. divdif, a library which constructs, evaluates and manipulates divided difference tables;
78. dunavant, a library which defines Dunavant quadrature rules in a triangle;
79. entrust, a library which uses trust-region methods to solve problems in scalar optimization or nonlinear least squares, by Borggaard and Cliff.
80. faure, a library which computes the Faure M-dimensional quasirandom sequence;
81. fd1d, a program which implements a finite difference algorithm for a 1D predator-prey system;
82. fd1d_heat, a program which implements a finite difference solution of the 1D heat equation;
83. fd1d_plot, a program which plots solutions from the FD1D program.
84. fekete, a library which sets up one of seven Fekete rules for interpolation or quadrature in a triangle;
85. fem_50, a program which implements a Finite Element Method solver using about 50 lines of MATLAB code;
86. fem_50_heat, a program which is a version of fem_50 for the time-dependent heat equation;
87. fem_basis_t3_display, a program which displays any single basis function associated with an arbitrary linear triangle ("T3") mesh;
88. fem_basis_t6_display, a program which displays any single basis function associated with an arbitrary quadratic triangle ("T6") mesh;
89. fem_io, a library which reads or writes FEM files, (three text files describing a finite element model);
90. fem_sample, a library which samples a finite element function, defined by FEM files, (three text files describing the nodes, triangles, and coefficients); at arbitrary points.
91. fem_to_tec, a program which reads a set of FEM files, (three text files describing a finite element model), and writes a TEC filesuitable for display by TECPLOT;
92. fem1d, a program which applies the finite element method, using piecewise linear basis functions, to a linear two point boundary value problem in 1D;
93. fem1d_adaptive, a program which uses an adaptive mesh when applying the finite element method, with piecewise linear basis functions, to a linear two point boundary value problem in 1D;
94. fem1d_nonlinear, a program which applies the finite element method, with piecewise linear basis functions, to a nonlinear two point boundary value problem in 1D;
95. fem1d_pmethod, a program which applies the p-method version of the finite element method to a linear two point boundary value problem in 1D;
96. fem2d_heat, a program which applies the finite element method for the time-dependent heat equation on a triangulated square in 2D;
97. fem2d_poisson, a program which applies the finite element method for Poisson's equation on a triangulated square in 2D;
98. fempack, a library which performs simple finite element computations;
99. ffh_sparse, a program which applies the finite element method to the heat equations on an arbitrary triangulated region in 2D. This is a special version of FREE_FEM_HEAT that uses MATLAB's sparse matrix features;
100. ffns_sparse, a program which applies the finite element method to the steady incompressible Navier Stokes equations on an arbitrary triangulated region in 2D. This is a special version of FREE_FEM_NAVIER_STOKES that uses MATLAB's sparse matrix features;
101. ffp_sparse, a program which applies the finite element method to the Poisson equations on an arbitrary triangulated region in 2D. This is a special version of FREE_FEM_POISSON that uses MATLAB's sparse matrix features;
102. ffs_sparse, a program which is a finite element code for the steady incompressible Stokes equations on an arbitrary triangulated region in 2D. This is a special version of FREE_FEM_STOKES that uses MATLAB's sparse matrix features;
103. filum, a library which handles files and filenames;
104. free_fem_heat, a program which applies the finite element method to the time dependent heat equation on an arbitrary triangulated region in 2D;
105. free_fem_navier_stokes, a program which applies the finite element method to the steady incompressible Navier Stokes equations on an arbitrary triangulated region in 2D;
106. free_fem_poisson, a program which applies the finite element method to Poisson's equation on an arbitrary triangulated region in 2D;
107. free_fem_stokes, a program which applies the finite element method for the steady incompressible Stokes equations on an arbitrary triangulated region in 2D;
108. gegenbauer_rule, a program which computes and writes out a Gauss-Gegenbauer quadrature rule of given order.
109. gen_hermite_rule, a program which computes and writes out a generalized Gauss-Hermite quadrature rule of given order and parameter value ALPHA.
110. gen_laguerre_rule, a program which computes and writes out a generalized Gauss-Laguerre quadrature rule of given order and parameter value ALPHA.
111. geometry, a library which performs 2D/3D geometric calculations;
112. geompack, a library which computes the Delaunay triangulation for a set of points in 2D;
113. gl_display, a program which displays the points used in a 2D Gauss-Legendre quadrature rule;
114. gm_rules, a library which defines Grundmann-Moeller quadratures rules for an M-dimensional simplex.
115. grid, a library which computes N random points on a uniform M dimensional grid;
116. grid_dataset, a program which creates a grid dataset;
117. halton, a library which calculates the Halton M-dimensional quasirandom sequence;
118. halton_dataset, a program which creates N elements of an M dimensional Halton sequence and write them to a file.
119. hammersley, a library which computes the Hammersley M-dimensional quasirandom sequence;
120. hammersley_dataset, a program which creates N elements of an M dimensional Hammersley sequence and write them to a file.
121. hb_io, a library which reads and writes files in the Harwell Boeing sparse matrix format;
122. hb_to_msm, a program which converts a sparse matrix stored in a Harwell Boeing file to MATLAB sparse matrix format;
123. hcell_flow_display, a program which plots the physical data, pressures or velocities, from a run of the HCELL program;
124. hermite_phys_product, a library which writes out a table of the integrals of products of pairs of Hermite (physicist) polynomials with a linear or exponential weight.
125. hermite_prob_product, a library which writes out a table of the integrals of products of pairs of Hermite (probabilist) polynomials with a linear or exponential weight.
126. hermite_rule, a program which computes and writes out a Gauss-Hermite quadrature rule of given order.
127. hex_grid, a library which generates a hexagonal grid of points in the unit square or an arbitrary rectangle;
128. hex_grid_angle, a library which defines a hexagonal grid of points in the unit square, with an arbitrary center, angle, and spacing.
129. hex_grid_dataset, a program which creates a hexagonal grid of points in a rectangle, and write them to a file, using the hex_grid library.
130. histogram_display, a program which makes a bar plot of a set of data stored as columns in a file; the first column is the X values, and all the other columns are Y values to be shown as a stack of bars;
131. hot_pipe, a program which demonstrates fem_50_heat to solve a particular heat equation problem;
132. hot_point, a program which demonstrates fem_50_heat to solve a particular heat equation problem;
133. ihs, a library which generates the Improved Distributed Hypercube Sampling M-dimensional quasirandom sequence;
134. ihs_dataset, a program which creates an IHS dataset and writes it to a file;
135. inout_flow_display, a library which displays a single velocity field solution for the INOUT flow;
136. inout_flow_movie, a library which creates an animation of the velocity solutions for the INOUT cell;
137. int_exactness, a program which tests the polynomial exactness of quadrature rules for a finite interval;
138. int_exactness_chebyshev1, a program which tests the polynomial exactness of Gauss-Chebyshev type 1 quadrature rules.
139. int_exactness_chebyshev2, a program which tests the polynomial exactness of Gauss-Chebyshev type 2 quadrature rules.
140. int_exactness_gegenbauer, a program which tests the polynomial exactness of Gauss-Gegenbauer quadrature rules.
141. int_exactness_gen_hermite, a program which tests the polynomial exactness of generalized Gauss-Hermite quadrature rules.
142. int_exactness_gen_laguerre, a program which tests the polynomial exactness of generalized Gauss-Laguerre quadrature rules.
143. int_exactness_hermite, a program which tests the polynomial exactness of Gauss-Hermite quadrature rules.
144. int_exactness_jacobi, a program which tests the polynomial exactness of Gauss-Jacobi quadrature rules.
145. int_exactness_laguerre, a program which tests the polynomial exactness of Gauss-Laguerre quadrature rules.
146. int_exactness_legendre, a program which tests the polynomial exactness of Gauss-Legendre quadrature rules.
147. jacobi_rule, a program which computes and writes out a Gauss-Jacobi quadrature rule of given order.
148. keast, a library which defines Keast quadrature rules in a tetrahedron;
149. kelley, a library which implements iterative methods for linear and nonlinear equations, by Tim Kelley;
150. laguerre_product, a library which writes out a table of the integrals of products of pairs of Laguerre polynomials with a linear or exponential weight.
151. laguerre_rule, a program which computes and writes out a Gauss-Laguerre quadrature rule of given order.
152. latin_center, a library which computes N points in an M-dimensional Latin Center square;
153. latin_edge, a library which returns N points in an M-dimensional Latin Edge square;
154. latin_random, a library which returns N points in an M-dimensional Latin Random square;
155. latinize, a program which adjusts N points in M dimensions to form a Latin hypercube;
156. lcvt, a library which makes a sort of Latinized CVT (centroidal Voronoi tesselation);
157. lcvt_dataset, a program which creates a Latinized CVT dataset;
158. legendre_product, a library which writes out a table of the integrals of products of pairs of Legendre polynomials with a linear or exponential weight.
159. legendre_rule, a program which writes out a Gauss-Legendre quadrature rule of given order.
160. lemke, a library which implements Lemke's algorithm for the linear complementarity problem, by Paul Fackler and Mario Miranda.
161. levels, a library which makes a contour plot, choosing the contour levels using random sampling.
162. linpack, a library which constitutes a linear algebra library;
163. linpack_bench, a program which is the LINPACK benchmark;
164. linpack_bench_backslash, a program which is the LINPACK benchmark, using MATLAB's buildin "backslash" operator;
165. linpack_c, a library which constitutes a linear algebra library for single precision complex arithmetic;
166. linpack_d, a library which constitutes a linear algebra library for double precision real arithmetic;
167. linpack_s, a library which constitutes a linear algebra library; for single precision real arithmetic;
168. linpack_z, a library which constitutes a linear algebra library; for double precision complex arithmetic (NOTHING HERE)
169. linplus, a library which factors/solves/multiplies matrices in a variety of formats;
170. lorenz_demo, a program which computes and displays solutions of the Lorenz equations;
171. machar, a library which dynamically computes the value of various machine characteristic constants;
172. machine, a library which returns tabulated values of the constants associated with computer arithmetic
173. matlab, examples which illustrate the use of MATLAB scripts and M-files;
174. matlab_batch, examples which illustrate how MATLAB can be run in "batch" mode, that is, non-interactively, on a UNIX system;
175. matlab_c, examples which illustrate how C functions can be written, compiled, and called from MATLAB using the MEX facility;
176. matlab_f77, examples which illustrate how FORTRAN77 functions can be written, compiled, and called from MATLAB using MATLAB's mex facility;
177. matlab_movies, examples which illustrate making movies using MATLAB;
178. matlab_os, examples which illustrate how the system command can be used to allow MATLAB to issue commands to the computer operating system (UNIX or DOS);
179. md is a program which carries out a molecular dynamics simulation, and is intended as a starting point for implementing an OpenMP parallel version.
180. memory_test, a program which tests the memory available on the computer by declaring and using big vectors.
181. mesh_bandwidth, a program which returns the geometric bandwidth associated with a mesh of elements of any order and in a space of arbitrary dimension.
182. mgmres, a library which applies the restarted GMRES algorithm to a sparse linear system;
183. mm_io, a library which reads and writes a Matrix Market Sparse Matrix File;
184. msm_to_hb, a program which writes a MATLAB sparse matrix to a Harwell Boeing file;
185. mxv, a program which compares the performance of (DO I, DO J) loops and (DO J, DO I ) loops for computing the product of an MxN matrix A and an N vector X.
186. nast2d_contour, a program which reads a data file from NAST2D_F90 and creates a contour plot;
187. nast2d_streak_display, a program which reads a streakline data file from NAST2D_F90 and displays an image of one time frame;
188. nast2d_streak_movie, a program which reads a streakline data file from NAST2D_F90 and creates a movie;
189. ncc_tetrahedron, a library which defines Newton-Cotes closed quadrature rules in a tetrahedron;
190. ncc_triangle, a library which defines Newton-Cotes closed quadrature rules in a triangle;
191. nco_tetrahedron, a library which defines Newton-Cotes open quadrature rules in a tetrahedron;
192. nco_triangle, a library which defines Newton-Cotes open quadrature rules in a triangle;
193. nelder_mead, a program which implements the Nelder-Mead algorithm for the minimization of a scalar function of several variables.
194. nested_sequence_display, a program which displays a set of nested sequences.
195. niederreiter2, a library which computes the Niederreiter M-dimensional quasirandom sequence, base 2;
196. nint_exactness, a program which demonstrates how to test the polynomial exactness of a multidimensional quadrature rule;
197. nint_exactness_tet, a program which tests the polynomial exactness of a quadrature rule for the tetrahedron;
198. nint_exactness_tri, a program which tests the polynomial exactness of a quadrature rule for the triangle;
199. nintlib, a library which carries out approximate integration (quadrature) in multiple dimensions;
200. normal, a library which generates uniform pseudorandom numbers;
201. optimal_control_1d, a program which seeks the optimal control function for a one dimensional system which is represented using the finite element formulation;
202. owens a library which evaluates Owen's T function;
203. pbma_io, a library which reads or writes an ASCII PBM; (Portable Bit Map) image file;
204. pce_legendre, a program which assembles the system matrix associated with a polynomal chaos expansion of a 2D stochastic PDE, using Legendre polynomials;
205. pgma_io, a library which reads or writes an ASCII PGM; (Portable Gray Map) image file;
206. ply_io, a library which reads or writes a PLY file.
207. ply_to_tri_mesh, a program which reads a PLY file, and extracts the surface mesh data as a TRI_MESH dataset.
208. points_01_plot, a program which reads an ASCII file containing points in the unit square, and makes an Encapsulated PostScript image;
209. points_display a program which reads a TABLE file containing the coordinates of points in 2D or 3D, and displays a plot of the points in a MATLAB graphics window;
210. polking programs, DFIELD5 and PPLANE5, for direction fields and phase planes of differential equations;
211. polpak a library which evaluates recursively defined polynomials and other special functions;
212. polygonal_surface_display a program which displays a surface in 3D described as a set of polygons;
213. power_method a library which carries out the power method for finding a dominant eigenvalue and its eigenvector.
214. ppma_io a library which reads or writes an ASCII PPM; (Portable Pixel Map) image file;
215. prob a library which evaluates and samples various probability density functions;
216. product_factor, a program which creates a multidimensional quadrature rule from a product of distinct 1d quadrature rules;
217. product_rule a program which creates a multidimensional quadrature rule from a product of identical 1d quadrature rules;
218. profile a directory of programs which illustrate the use of the MATLAB profile utlity, which monitors the execution of a series of MATLAB commands, and then produces a performance profile report afterwards.
219. puzzles, executable programs which solve simple puzzles;
220. quad_mesh_display, a program which plots piecewise bilinear data associated with a quadrilateral mesh;
221. quadrature_test a program which reads the definition of a multidimensional quadrature rule from three files, applies the rule to a number of test integrals, and prints the results.
222. quadrule a library which defines quadrature rules for approximating an integral;
223. quadrule_fast a library which rapidly defines certain quadrature rules for approximating an integral;
224. quality a library which measures the dispersion of pointsets in M dimensions;
225. random_data, a library which generates sample points for various probability density functions, geometries, and dimensions;
226. rcm, a library which applies the reverse Cuthill McKee algorithm for reordering the nodes of a graph, and reducing the bandwidth of a corresponding sparse matrix;
227. region_sample, a program which returns sample points from a region;
228. sandia_rules, a library which produces a standard 1D Gauss quadrature rule of Chebyshev, Gegenbauer, generalized Hermite, generalized Laguerre, Hermite, Jacobi, Laguerre, and Legendre types.
229. sandia_sparse, a library which can produce a multidimensional sparse grid, based on a variety of 1D quadrature rules; only isotropic grids are generated, that is, the same rule is used in each dimension, and the same maximum order is used in each dimension.
230. satisfiability is a program which demonstrates, for a particular circuit, an exhaustive search for solutions of the circuit satisfiability problem.
231. sde, a library which illustrates the properties of stochastic differential equations, and common algorithms for their analysis, by Desmond Higham;
232. sequence_streak_display, a program which displays a "streak plot" of a numeric sequence;
233. sobol, a library which generates elements of the Sobol M-dimensional quasirandom sequence;
234. sp_level_closed, a program which creates a sparse grid dataset based on closed rules (Clenshaw-Curtis, Newton-Cotes-Closed).
235. sp_level_open, a program which creates a sparse grid dataset based on open rules (Fejer 1, Fejer 2, Gauss-Patterson, Newton-Cotes-Open, Newton-Cotes-Open-Half).
236. sparse, a directory of example programs which illustrate the use of MATLAB's SPARSE matrix utilities;
237. sparse_grid_cc, a library which creates sparse grids based on Clenshaw-Curtis rules.
238. sparse_grid_cc_dataset, a program which creates sparse grids based on Clenshaw-Curtis rules.
239. sparse_grid_closed, a library which creates sparse grids based on closed rules (Clenshaw-Curtis, Newton-Cotes-Closed).
240. sparse_grid_display, a program which reads a file of points on a sparse grid, displays the grid and save the image in a PNG file;
241. sparse_grid_gl, a library which creates sparse grids based on Gauss-Legendre rules.
242. sparse_grid_gl_dataset, a program which creates a sparse grid dataset based on Gauss-Legendre rules.
243. sparse_grid_hermite, a library which creates sparse grids based on Gauss-Hermite rules.
244. sparse_grid_hermite_dataset, a program which creates a sparse grid dataset based on Gauss-Hermite rules.
245. sparse_grid_laguerre, a library which creates sparse grids based on Gauss-Laguerre rules.
246. sparse_grid_laguerre_dataset, a program which creates a sparse grid dataset based on Gauss-Laguerrre rules.
247. sparse_grid_open, a library which creates sparse grids based on open rules (Fejer 1, Fejer 2, Gauss-Patterson, Newton-Cotes-Open, Newton-Cotes-Open-Half).
248. sparse_grids_display, a program which reads two files of sparse grids, displaying the first with hollow blue dots, the second with solid red dots.
249. spinterp, a library which carries out piecewise multilinear hierarchical sparse grid interpolation, by Andreas Klimke; ACM TOMS Algorithm 847.
250. spline, a library which interpolates and approximates via splines;
251. stla_display, a program which displays an STLA file (ASCII stereolithography 3D graphics file);
252. stla_io, a library which reads and writes an STLA file (ASCII stereolithography 3D graphics file);
253. stroud, a library which implements numerical integration over M-dimensional regions, including spheres, toruses and other shapes;
254. subpak, a library which includes many utility routines;
255. subset, a library which ranks, unranks, and generates random subsets, combinations, permutations, and so on;
256. sudoku, a library which handles Sudoku puzzles;
257. sum_million, a program which sums the integers from 1 to 1,000,000, as a demonstration of how to rate a computer's speed;
258. svd_basis, a program which applies the singular value decomposition to a collection of data vectors, extracting dominant modes;
259. svd_demo, a program which demonstrates the calculation of the singular value decomposition and some of its properties;
260. table_io, a library which reads and writes a simple TABLE file;
261. table_latinize, a program which reads a TABLE file of N points in M dimensions, adjusts to form a Latin hypercube;
262. table_merge, a program which reads a TABLE file of N points in M dimensions, removes duplicates or points that are closer than some tolerance, and writes the reduced set of points to a file.
263. table_quality, a program which reads a TABLE file of N points in M dimensions, in the unit hypercube, and returns estimates of the quality of the point dispersion;
264. table_read, a program which reads a TABLE file containing comment lines beginning with '#', and a matrix of data, one row per line;
265. tcell_flow_display, a library which displays a single velocity field solution for the T cell;
266. tcell_flow_movie, a library which creates an animation of the velocity solutions for the T cell;
267. tcell_rom, a program which solves a reduced order model of a finite element solution of the Navier Stokes equations in a "T-Cell" flow region;
268. tec_io, a library which reads or writes a TEC file containing finite element information;
269. tec_to_fem, a program which reads a TEC file suitable for display by TECPLOT, extracts the information, and writes a corresponding set of FEM files, three text files describing the finite element model;
270. templates, a library which carries out the iterative solution of linear systems;
271. test_int_hermite, a library which implements test problems for approximate integration over an infinite interval.
272. test_int_laguerre, a library which implements test problems for approximate integration over a semi-infinite interval.
273. test_mat a library which defines a set of test matrices.
274. test_matrix, a library which defines a set of test matrices and utilities, by Nick Higham;
275. test_nint, a library which implements test problems for approximate integration (quadrature) in multiple dimensions.
276. test_ode, a library which defines some sample ODE's for testing initial value problem solvers;
277. test_tri_int, a library which implements test functions for integration over a triangle in 2 dimensions.
278. test_triangulation, a library which defines test problems for triangulation;
279. test_values, a library which returns selected values of some special functions;
280. test_zero, a library which defines some functions f(x) suitable for testing software that solves f(x)=0;
281. testpack a library which defines a set of test integrand functions by Alan Genz.
282. tet_mesh a library which works with tetrahedral meshes in 3D;
283. tet_mesh_display, a program which reads data defining a (small) tet mesh, displays a wireframe image of the nodes and edges;
284. tet_mesh_l2q, a program which reads information about a 4-node (linear) tet mesh and creates data defining a corresponding 10-node (quadratic) tet mesh;
285. tet_mesh_q2l, a program which reads information about a 10-node (quadratic) tet mesh and creates data defining a corresponding 4-node (linear) tet mesh;
286. tet_mesh_quality, a program which computes various quality measures for a tet mesh of a set of nodes in 3D;
287. tet_mesh_rcm, a program which computes the reverse Cuthill-McKee reordering for the nodes of a tet mesh that uses 4-node or 10-node tetrahedrons;
288. tet_mesh_refine, a program which refines a tet mesh;
289. tet_mesh_tet_neighbors, a program which reads information about a tet mesh and writes out a list of the tetrahedrons that are adjacent to a given tetrahedron;
290. timer, examples which illustrate how to time a piece of code;
291. timestamp, a library which prints the current YMDHMS date as a timestamp;
292. toms178 a library which seeks the minimizer of a scalar function of several variables using the Hooke-Jeeves method;
     this is a MATLAB version of ACM TOMS algorithm 178.
293. toms179 a library which calculates the incomplete Beta ratio;
     this is a MATLAB version of ACM TOMS algorithm 179.
294. toms291 a library which approximates the logarithm of the Gamma function;
     this is a MATLAB version of ACM TOMS algorithm 291.
295. tri_mesh_display, a program which displays a surface in 3D described as a mesh of triangles;
296. tri_mesh_to_ply, a program which converts a TRI_MESH dataset to a dataset suitable for storage as a PLY file.
297. triangulation, a library which computes the triangulation of a set of points in the plane, and to perform various operations using a triangulation;
298. triangulation_boundary_nodes, a program which reads data defining a triangulation, determines which nodes lie on the boundary, and writes their coordinates to a file;
299. triangulation_corner, a program which modifies triangulations in which one or more triangles have more than one boundary edge.
300. triangulation_l2q, a program which reads information about a 3-node (linear) triangulation and creates data defining a corresponding 6-node (quadratic) triangulation;
301. triangulation_mask, a program which reads a triangulation and calls a user-supplied routine to consider each triangle for deletion;
302. triangulation_order1_display, a program which plots piecewise constant data associated with a triangulation;
303. triangulation_order3_contour, a program which plots color contours of a scalar quantity evaluated at the nodes of a 3-node triangle triangulation.
304. triangulation_order6_contour, a program which plots color contours of a scalar quantity evaluated at the nodes of a 6-node triangle triangulation.
305. triangulation_orient, a program which ensures that the triangles in an order 3 or order 6 triangulation have positive orientation;
306. triangulation_plot, a program which plots the nodes and elements of a triangulation;
307. triangulation_q2l, a program which reads information about a 6-node triangulation and creates data defining a corresponding 3-node triangulation;
308. triangulation_quality, a program which reads information about a triangulation and computes various quality measures;
309. triangulation_rcm, a program which computes the reverse Cuthill-McKee reordering for the nodes of a triangulation that uses 3-node or 6-node triangles;
310. triangulation_refine, a program which refines a triangulation;
311. triangulation_triangle_neighbors, a program which reads data defining a triangulation, finds the three neighbor triangles for each triangle, and writes them to a file;
312. tumor, a program which demonstrates a model of tumor growth;
313. uniform, a library which computes N elements of a uniform pseudorandom sequence;
314. uniform_dataset, a program which creates N elements of an M dimensional uniform pseudorandom sequence and writes them to a file.
315. van_der_corput, a library which computes elements of the van der Corput 1-dimensional quasirandom sequence;
316. van_der_corput_dataset, a program which creates N elements of a van der Corput sequence and writes them to a file.
317. vector_magnitude_grid, a program which reads vector data at "scattered" points, computes an interpolatory function, evaluates it on a uniform grid of user-specified density, and produces a contour plot of the vector magnitude.
318. vector_stream_grid, a program which reads vector data at "scattered" points, computes an interpolatory function, evaluates it on a uniform grid of user-specified density, and produces a streamline plot.
319. velocity_arrows, a program which reads coordinate data and velocity data from two files and makes an arrow plot of the velocity field.
320. velocity_arrows_grid, a program which reads node and velocity data, stored in two files, at "scattered" points, and makes a velocity vector plot on a uniform grid of user-specified density.
321. velocity_arrows_grid_sequence2, a program which reads a single XYUV file of nodes and velocities, interpolates the data onto a smooth grid, plots the data and writes it to a PNG file, and then repeats the process for the next file.
322. velocity_arrows_grid2, a program which reads node and velocity data, stored in one file, at "scattered" points, and makes a velocity vector plot on a uniform grid of user-specified density.
323. velocity_arrows_sequence, a program which reads a fixed coordinate data file, and a sequence of velocity data files, and makes a sequence of velocity arrow plots.
324. velocity_arrows_sequence2, a program which reads a single XYUV file of nodes and velocities, plots the data and writes it to a PNG file, and then repeats the process for the next file.
325. velocity_arrows2, a program which reads coordinate and velocity data from a single file and makes an arrow plot of the velocity field.
326. voronoi_mountains, a program which makes a "mountain plot" of a Voronoi diagram, that is, a surface plot of the distance from each point to its nearest Voronoi generator.
327. voronoi_new, a program which is a revised version of MATLAB's voronoi command, and does a better job with the boundaries of the infinite regions;
328. wandzura, a library which returns one of 6 Wandzura rules for quadrature in a triangle;
329. xy_io, a library which reads and writes XY files.
330. ziggurat, a library which samples the uniform, normal or exponential distributions, using the ziggurat method.

---

Last revised on 15 July 2008.