For special pointsets over intervals, triangles (simplex), disk, square, and polygons, see the following url.
Recent codes
(last update: November 23, 2023)
» Object: Near-algebraic quadrature rules on spherical polygons..
The suite is subdivided in two folders, EASY and NUMERICAL_EXPERIMENTS.
In EASY there are two subfolders CUB and HYP in which we provide the codes for cubature and hyperinterpolation (respectively).
In CUB there is the demo demo_cub_sphpgon that shows how to use the main routine cub_sphpgon and a basic adaptive code adaptive_cub_sphpgon.
In HYP there is the demo demo_hyp_sphpgon that shows how to compute hyperinterpolants on spherical polygons.
In NUMERICAL_EXPERIMENTS there are three subfolders CUB01 and HYP01, HYP02 in which we provide the codes used for experiments about cubature and hyperinterpolation and its variants (respectively).
The main folder contains several subfolders that lead to the wanted domain. In particular we examine the Lebesgue constants for some interpolation sets in the
interval,
simplex,
square,
disk,
cube,
ball,
as well as we analyse the Lebesgue constant for Least-Squares on
square,
disk.
Each folder contains:
demo_basic.m that is a basic demo for understanding how the Lebesgue costant estimator lebconst_eval_*.m works;
demo_leb_*.m makes all the experiments cited in the paper
L. Bialas-Ciez, D. Kenne, A. Sommariva and M. Vianello, Evaluating Lebesgue constants by Chebyshev polynomial meshes on cube, simplex and ball.
The folder _DATA contains the plots of the papers, a file "numerical_experiments.txt" with the statistics of the experiments, and if it is useful, the files set_AFP_disk, set_DLP_disk containing respectively Approximate Fekete Points and Discrete Leja Points for mild degrees.
» Sources:
Papers:
Leokadia Bialas-Ciez, Dimitri Jordan Kenne, Alvise Sommariva, Marco Vianello, Evaluating Lebesgue constants by Chebyshev polynomial meshes on cube, simplex and ball.
» First update: November 23, 2023. Last update: November 23, 2023.
Usage notes:
demo_complex_driver
To run the demo that determines the figures in the paper "Chebyshev admissible meshes and Lebesgue constants of complex polynomial projections", and that in particular
defines AM (Admissible Mesh),
computes some interpolation pointsets,
determines a certified approximation of Lebesgue constants of such sets as well as of the Least-Squares operator based on some Admissible Meshes of a certain degree,
plots domains, some pointset and a certified approximation of Lebesgue constants up to some degree,
just type in the Matlab shell "demo_complex_driver" with values of the argument ranging from 1 to 18, and degrees of your choice.
demo_complex_AM
To run the demo that
defines AM (Admissible Mesh) of fixed degree on some domain,
determines the Lebesgue constant of the associated Least-Squares operator,
plots AM of some degree ,
just type in the Matlab shell "demo_complex_AM" with values ranging from 1 to 18, and the degree of the AM.
» Sources:
Papers:
Leokadia Bialas-Ciez, Dimitri Jordan Kenne, Alvise Sommariva, Marco Vianello, Chebyshev admissible meshes and Lebesgue constants of complex polynomial projections.
» First update: November 4, 2023. Last update: November 4, 2023.
Usage notes:
The main Matlab code used in our numerical tests, can be found in the folder "General"
and is named "demo_scattcub_driver_01.m".
There You can change the domain, the algebraic degrees of exactness of the rule, cardinali-
ty and type of the scattered data.
For a simple usage of the algorithm, we have added the routine "demo_scattcub", where one can use one of the algorithms
to compute the wanted integrals. It makes comparisons with the algebraic rule used in the integral evaluation knowing the function evaluations at the nodes.
IMPORTANT: The directory "EXTERNAL_ROUTINES" contains methods and cubature rules used in the paper.
» Sources:
Papers:
R. Cavoretto, F. Dell'Accio, A. De Rossi, F. Di Tommaso, N.
Siar, A. Sommariva, and M. Vianello, Numerical cubature on scattered data by adaptive interpolation.
» First update: June 02, 2023. Last update: August 27, 2023.
» Object: Qsurf: a software package for compressed QMC integration on parametric surfaces
The main folder contains the following files:
demo_CQMC_sphpoly: In this demo we compute a cubature rule over spherical polygons via QMC rules. Once the domain is available, we compute a full rule QMC and a compressed one, say CQMC, sharing the same integrals for polynomials up to a total degree.
demo_CQMC_torus: same as above on a subdomain of a toroidal surface;
demo_CQMC_franke: same as above on a subdomain of a surface given by Franke's function.
pts_domain: corresponds to items (i) and (ii) of Algorithm Qsurf (see attached paper);
cqmc_v2: corresponds to items (iii) and (vi) of Algorithm Qsurf (see attached paper);
dCHEBVAND_v2: basis selection in item (iii) of Algorithm Qsurf (see attached paper);
lawsonhanson, LHDM: NNLS implementation;
dCATCH, implements Caratheodory-like compression via NNLS.
» First update: April 13, 2023. Last update: September 5, 2023.
» Object: qBubble: a software package compressed QMC volume and surface integration on union of balls.
The main folder contains the following files:
demo_CQMC: In this demo we compute a cubature rule on a union of balls or on its surface via QMC rules. Once the domain is available, we compute a full rule QMC and a compressed one, say CQMC, sharing the same integrals for polynomials up to a total degree.
demo_CQMC_battery: numerical cubature over volumes/surfaces defined by union of balls/spheres. The routine tests the quality of quadrature rules with degree of precision "deg" over polynomials of the form f=@(x,y,z) (a1+b1*x+c1*y+d1*z).^deg; where "a1", "b1", "c1", "d1" are random numbers. Finally it plots, if requires, the relative errors of each test, for some "deg" and logarithmic averages.
cqmc_v2: the routine computes a Compressed Quasi-Monte Carlo formula from a large low-discrepancy sequence on a low-dimensional compact set preserving the QMC polynomial moments up to a given degree, via Tchakaloff sets and NNLS moment-matching.
Constructive approximation of functions 3 (Krakow, Poland, 22-24 February 2023)
» [PDF]
,
» First update: November 29, 2022. Last update: November 29, 2022.
» Object: TetraFreeQ: a software package for Tchakaloff-like quadrature on polyhedral elements.
The main folder contains the following files:
demo_01: battery of tests will be performed, on different polyhedra, for the methods working with or without triangulation; the software compares the performance of the method, on random polynomials of total degree "ade".
demo_02: single cubature test over polyhedra (convex or concave, even with odd shapes); the demo expains the subroutines usage.
cubature_polyhedron_free: cubature over polyhedral elements without tetrahedralization;
cubature_polyhedron_tri: cubature over polyhedral elements via tetrahedralization;
» First update: November 29, 2022. Last update: November 29, 2022.
» Object: UNIONOFDISKS: a software package for determining cubature rules over union of disks.
The main folder contains the following compressed folders:
COMPARISONS, contains all the subroutines used for our numerical experiments (including previous software that is compared with the new approach); the main demo is the file demo make experiments that performs the numerical experiments presented in the paper Cubature rules with positive weights on union of disks, comparing the new rules determined by cub_uniondisks, including the compressed version, and the old routine achieved by gqmultibubble;
demo_make_experiments: it performs the experiments presented in the paper;
demo_cubature_uniondisk: it compares the results of new rules (including the compresse one) on integrating some functions on certain test domains;
ROUTINES, contains all the routines necessary for cubature over disks; the main routines are
cub_uniondiscs: implements the algorithm for determining a cubature formula on the union of disks, including the Tchakaloff rules (i.e. their compressed version);
demo_cub_uniondiscs: demo explaining how to use the subroutines and comparing the new rules on some domains.
» Sources:
Papers:
[1] A. Sommariva and M. Vianello, Cubature rules with positive weights on union of disks, (submitted),
» First update: October 24, 2022. Last update: October 24, 2022.
» Object: CQMC: a software package for low-dimensional Compressed Quasi-MonteCarlo cubature.
The main folder contains the following compressed folders:
ROUTINES_2D.zip, that include many routines for computation of integrals via QMC/CQMC methods on domains obtained by set operation from two
bivariate domains whose boundary is defined by piecewise NURBS;
ROUTINES_3D.zip, that include many routines for computation of integrals via QMC/CQMC methods on domains obtained by set operation from a
trivariate polyhedron and a sphere;
README_FIRST.txt, that explains how to replicate the tests in the paper.
In both cases, the main routines are:
make_rule, that defines a QMC rule over the domain and then extracts the CQMC rule via cqmc_01;
cqmc_01, routine that from a sufficiently dense QMC rule computes a low cardinality CQMC rule that matches the QMC moments up to a certain total polynomial degree.
» Sources:
Papers:
[1] G. Elefante, A. Sommariva and M. Vianello, CQMC: an improved code for low-dimensional Compressed
Quasi-MonteCarlo cubature, (submitted),
» Object: IN_RS: Matlab routine for points indomain on NURBS-shaped planar domains.
The main folder IN_RS contains:
» inRS.m, a new routine for indomain over NURBS-shaped domains;
» inRS_21.m, an old routine for indomain over NURBS-shaped domains;
» inRSpoly2.m, a routine for indomain over NURBS-shaped domains (based on approximating the domain with a polygon, it requires inpoly2 by D. Engwirda);
» demo_nurbs_indomain_01.m, demo_nurbs_indomain_02.m, demo_nurbs_indomain_03.m are demos, useful to define the domains and to understand how to use the indomain routine.
» demo_nurbs_indomain_04.m, evaluates the performance of our two indomain routines for NURBS presented in [1] and [2], comparing them to one in which the NURBS boundary is approximated by a polygon, finally using
inpoly2 by D. Engwirda. To make that comparison, please download the routine inpoly2 and save it in the IN_RS folder.
» the routine demo_nurbs_indomain_05.m shows how to define the problem when only some vertices of the curved polygon are available;
» the routine demo_nurbs_indomain_06.m considers the case of a domain whose boundary is defined only by a point cloud of possibly inexact data; this routine requires
spcsp.m (cubic smoothing periodic spline), by M. Zanetti, available at the
Matlab Central File Exchange;
» the routine demo_nurbs_indomain_07.m shows how to define the problem when the whole domain is defined via point cloud and NURBS use the vertices, provided by alphashape polygonal approximation of the boundary, as control points;
» the routine demo_nurbs_indomain_08.m shows how to define the problem when the whole domain is defined via point cloud and parametric cubic smoothing periodic spline are used on the data provided by alphashape polygonal approximation of the boundary; this routine requires spcsp.m, by M. Zanetti, available at the
Matlab Central File Exchange;
» Sources:
Papers:
» [1] A. Sommariva and M. Vianello, Low-cardinality Positive Interior cubature on NURBS-shaped domains, [PDF] » [2] A. Sommariva and M. Vianello, inRS: implementing the indicator function for NURBS-shaped planar domains[PDF].
Codes:
» First update: January 07, 2022. Last update: February 22, 2022.
» Object: CUB_RS: Matlab toolbox for algebraic cubature on NURBS-shaped domains.
The main folder CUB_RS contains:
PAPER_EXPERIMENTS that includes all the Matlab routines useful for reproducing the experiments described in the work [1] and [2] (see references below);
BEZIER_ROUTINES that includes all the Matlab routines useful for integration over domains whose boundary is defined by composite Bezier arcs;
NURBS_ROUTINES that includes all the Matlab routines useful for integration over domains whose boundary is defined by NURBS;
SPLINE_ROUTINES that includes all the Matlab routines useful for integration over domains whose boundary is defined by general parametric splines.
All these folders contain several demos, useful to define the domains, to understand how to use the indomain routine as well as the cubature routine. Some examples on hyperinterpolation are also available.
The main routines are:
inRS that implements a fast indomain algorithm for these instances; the last update presents a faster indomain algorithm inRS, presented in [2]; the older version introduced in [1] is present in the file inRS_21;
cubRS that determines an algebraic cubature formula of the desired degree of exactness, with low cardinality, internal nodes and positive weights.
» Sources:
Paper:
»
[1] A. Sommariva and M. Vianello, Low-cardinality Positive Interior cubature on NURBS-shaped domains, [PDF];
» [2] A. Sommariva and M. Vianello, inRS: implementing the indicator function for NURBS-shaped planar domains.
Codes:
» Object: RBF cubature on polygonal regions (with almost optimal shape parameter).
The main routines are:
RBF_cub_polygon_OPT.m that determines the RBF based cubature rule on the polygonal region;
RBF_moms_polar.m and RBF_moms_tri.m that determines the RBF moments on the polygonal region;
RBF_optimal_scale.m that chooses the optimal RBF scale parameter;
The software includes several demos:
demo_RBF_cub_OPT.m that performs a battery of tests, allowing different integrands, polygonal regions, RBF, number of centers and choices of the RBF shape parameter.
demo_RBF_cub_OPT_basic that performs a simple example, on a certain integrand, polygonal region, RBF, number of centers and with almost optimal RBF shape parameter (useful to adapt the code to user experiments).
For the demos of the previous version published in RBF moment computation and meshless cubature on general polygonal regions, see:
RBF_cub_polygon.m that determines the RBF based cubature rule on the polygonal region (not optimized shape parameter);
» Source:
Papers:
R. Cavoretto, A. De Rossi, A. Sommariva and M. Vianello, RBFCUB: a numerical package for near-optimal meshless cubature on general polygons;
» Object: Approximation/Interpolation on spherical triangles.
The zip file contains three folders:
BASIC_USAGE: here we have introduced a demo demo_am_00.m on the norming mesh and its properties as well as the main routine am_sphtri.m for the determination of the norming mesh, depending on a spherical triangle contained in a certain hemisphere.
ADVANCED_USAGE: here there are two demos for the computation of norming meshes on spherical triangle T, as well as a set of Approximate Fekete Points, useful for polynomial interpolation.
demo_am_01.m demo on using "dPOLYFIT", "dPOLYVAL", "dLEB" for algebraic polynomial interpolation/least squares approximation on spherical triangle. The approximation points are taken from AMs on the spherical triangle; the new routine introduced here is "am_sphtri" that determines an Admissible Mesh over a spherical triangle.
demo_am_02.m this routine computes a AM on a spherical triangle and extracts AFEK pointset; next it determines its main features and plots AM and AFEK.
FIGURES: it contains all the Matlab files useful for determining the figures and their experiments, as cited in the reference paper Chebyshev-Dubiner norming grids and Fekete-like interpolation on spherical triangles.
» Object: Near-algebraic quadrature rules on spherical triangles..
The main routine is
cub_sphtri.m that determines full and compressed quadrature rules with fixed (numerical) algebraic degree of precision on spherical triangles; it requires dCATCHsph.m, dCHEBVAND.m, gqcircsect.m, LHDM.m, trigauss.m.
The software includes the demos files:
demo_01.m that tests the cubature rules on spherical harmonics (it requires sphharmVAND.m and plot_s2.m),
demo_02.m that tests the cubature rules on a battery of tests functions.
» Object: Polynomial hyperinterpolation on spherical triangles.
The software includes the demos files:
demo_hyperinterpolation_01.m that tests the hyperinterpolants of several functions on some spherical triangles,
demo_hyperinterpolation_02.m that shows how to determine the hyperinterpolant on a single example.
demo_hyperinterpolation_03.m that shows estimates of the Lesbegue constant based on Christoffel function.
» Object: RBF moments and cubature rules on polygonal regions.
The main routine are
RBF_moms_polar.m and RBF_moms_tri.m that determines the RBF moments on the polygonal region;
RBF_cub_polygon.m that determines the RBF based cubature rule on the polygonal region;
The software includes several demos that test moments as well as the cubature rules. In particular the tests in the paper can be obtained by means of demo_RBF_moms.m and demo_RBF_cub.m.
Incurvpolygon_cheb: indomain routine on bivariate Jordan domains whose boundary is defined by chebfuns.
The files are stored in the compressed folder, that contains:
» incurvpolygon_cheb.m: it is an indomain routine on domains defined whose boundary is defined by chebfuns;
» in the folder there is a demo demo_incurvpolygon_cheb.m, that tests the provided software.
ChebfunGauss: a Matlab code for cubature on Jordan bivariate domains defined analytically and approximated by Chebfuns.
The files are stored in the compressed folder, that contains:
» chebcub_2019.m: it is a more stable version of the previous software and quickly produces a rule with many points, of the choosen degree of precision;
» chebfuncub_compression.m: by this routine one can compress the previous rule to one with the same degree of precision but fewer nodes; first it tries to compute one with internal nodes and positive weights, then one with internal nodes and possible negative weights, then one with possible external nodes and positive weights and finally one with possible external nodes and possible negative weights;
» chebcub_2020.m: it is a version that produces a rule with few points, of the choosen degree of precision (the rule has internal nodes and usually positive weights);
» incurvpolygon_cheb.m: it is an indomain routine on bivariate Jordan domains defined whose boundary is defined by chebfuns;
In this software, we define a Matlab code for establishing numerically if a point is inside or on the boundary of a spline-curvilinear polygon (the so called "in domain" algorithms). The main routine is incurvpolygon.m.
Several demos are available, that show how to use incurvpolygon.m.
Fast Matlab codes for computing algebraic cubature rules on spline-curvilinear polygons. In general the cubature formula may have points outside the domain as well as negative weights.
The main routine is the m. file splinegauss_2020.m that performs cubature over domains with spline curvilinear boundaries. In case one wants to recover rules with less points (possibly with points in the domain and positive weights) one can try to achieve such rule by the routine splinegauss_compression.m.
Several demos are available, that show how to use splinegauss_2020.m and splinegauss_compression.m to produce cubature rules over spline-curvilinear polygons.
Object: this software computes algebraic cubature rules with fixed degree of precision over spline-curvilinear polygons. It includes an in-domain routine incurvpolygon.m that determines if a point is inside one of such regions.
The cubature formula has all points inside the domain as well as positive weights.
Object: this software computes algebraic cubature rules with fixed degree of precision over general polygons (convex or not convex, connected or disconnected, simply or not simply connected). It needs Matlab-built in polyshape environment.
Object: this software computes cubature rules over the sphere, via Radial Basis Functions and Spherical Radial Basis Functions. We point out that as described in demoRBFweights.m and demoSRBFweights.m , cubature weights are obtained, without the need of the RBF interpolant (though via moments and transpose of Vandermonde matrix).
» Paper: Integration by RBF over the sphere » Source: [.zip],
» First Version: May 2005, Last update: September 26, 2019.
Object: this software computes cubature rules over disks and annular sectors, via Radial Basis Functions. We point out that as described in demoRBFweights.m, cubature weights are obtained, without the need of the RBF interpolant (though via moments and transpose of Vandermonde matrix).
» Paper: Meshless cubature over the disk by Thin-Plates Splines » Source: [.zip],
» Old sources: [GreenDisk_v1_0.zip], [GreenDisk_v1_0a.zip] » First Version: 2008, Last update: September 24, 2019.
Object: this software computes cubature rules over rectangles, via Radial Basis Functions. The first .zip file considers RBF with the same scale for all the centers, the second zip file manages the variable scale case.
We point out that as described in demo_2019_weights.m, cubature weights can be obtained, without the need of the RBF interpolant.
» Paper: Numerical cubature on scattered datas by Radial Basis Functions » Source: [.zip], [.zip] » First Version: May 2004, Last update: September 23, 2019.
Object: this software computes cubature rules over polygons (convex or not convex), via Radial Basis Functions (Thin Plate Splines)
» Paper: Meshless cubature by Green's formula. » Source: [.zip] » First Version: May 2006, Last update: September 11, 2019.
» Source: [ZIP] » Last update: July 27, 2012 (Tested August 22, 2016)]
» Object: The MULTIVOP_220816.zip suite allows to compute hyperinterpolants over general regions. Here we show examples on some circular regions or polygons. The more important routine is multivop.m (see the paper http://www.math.unipd.it/~marcov/pdf/multivop.pdf) that allows the numerical computation of orthogonal polynomials over general regions.
» Source: Matlab code for Gauss-like cubature over polygons [MULTIVOP_220816] » Last update: August 25, 2016.
» Object: The routine trigauss.m computes a quadrature rule over an interval, exact for trigonometric polynomial degree N. Several versions, including the Gauss-Kronrod version (it is not known if they always exist!), are available.
» Source:
» Object:
Software for 1D trigonometric hyperinterpolation and hyperinterpolation over spherical rectangles. HYPERTRIG is based on trigonometric tensorial hyperinterpolation, while HYPERPOL consists in polynomial hyperinterpolation over spherical rectangles (of total degree).
For details, see the paper G. Da Fies, A. Sommariva and M. Vianello, Subperiodic trigonometric hyperinterpolation.
» Source:
» Object:
Demo of least squares on a 2D mesh and least squares on a compressed mesh. Examples on union of disks and polygons.
For details, see the paper F. Piazzon, A. Sommariva and M. Vianello, Caratheodory-Tchakaloff Subsampling.
» Source:
Matlab code for cubature over a square [Padua_CC.zip] (using non tensorial Padua and Morrow-Patterson Xu points).
The main routine is the m. file main.m that performs cubature over a square using different formulas. All numerical experiments have
been tested on Intel Centrino Duo T2400, with Windows XP, Matlab 6.1.0.450 Release 12.1 and GNU Octave 2.1.73.
[Last update: October 09, 2007]
Software for Padua points interpolation and cubature. [Padua2DM.tar.gz].
Some routines that can be used to make experiments with WAMs can be found in the following compressed files:
[WAM_2D_280210.zip]: a complete version that works on several bivariate domains, not easily adaptable to add own WAMs but right for experiments on general 2D domains.
[WAM_2De_010310.zip]: a simple version that does not work on many bivariate domains, but that is easily adaptable to add 2D WAMs.
[WAM_3D_010310.zip]: a simple version that does not work on many trivariate domains, but that is easily adaptable to add 3D WAMs.
[Last update: March 01, 2010]
Old versions of our software
ChebfunGauss: a Matlab code for Gauss-Green cubature by the Chebfun package: Matlab code that uses a suitable version of Splinegauss for
bivariate domains defined analytically and approximated by Chebfuns. The files are stored in the compressed folder
[CHEBFUNGAUSS_2017.zip]. For a demo use the file demo.m, for plotting cubature points plot_pts.m.
» Source:
» Object: The polygauss.m routine allows the computation of cubature rules with a certain degree of exactness on a polygon (without self-intersections). The new routine works via quadrangles panelling or triangularization. Some new demos show its usage. We point out that these rules can be compressed, providing a rule with less nodes/weights but the same algebraic degree of exactness (see comprexcub.m).
» Source:
Previous version:
Matlab code for Gauss-like cubature over polygons [GAUSSCUB_2013.zip].
The main routine is the m. file polygauss.m.
As demo, please use demo_gausscub.m. A different version, that uses less points but is more time expensive is polygaussj.m. We
point out that the routines work in the GNU Octave version 2.1.73 (i686-pc-cygwin) environment. For some numerical experiments in Matlab/Octave see
[readme_polygauss.pdf].
April 30, 2013: Modification of polygauss.m outputs.
For a numerical comparison, see the routine that calls "dblquad" [dblquad_polygons.zip].
[Last update: March 23, 2013]
Matlab code for Gauss-like cubature over spline curvilinear polygons [SPLINEGAUSS_2009.zip].
The main routine is the m. file splinegauss_2009b that performs cubature over domains with spline curvilinear boundaries..
As demo, please use demo.m for computing cubature over spline curvilinear polygons. In addition, try demo_splinegauss_moments.m for tests on computing moments w.r.t. some specific bases on such
domains. All numerical experiments have
been done on MAC Book, with MAC OS X, Matlab 7.6.0.324 Release 2008a. [Latest update: November 19, 2009].
If you are interested in this software, see the more recent routine in SPLINEGAUSS_2020.zip.
[Last update: March 27, 2009]
[POLYGINT_010411.zip] contains several Matlab files for cubature/interpolation over polygons based on AFP
(Approximate Fekete
Points) and DLP (Discrete Leja Points).
The zip file contains also Matlab routines for a minimal triangulation of a polygon and a quadrangulation of a polygon using few quadrangles and triangles.
[Last Update: April 01, 2011]
LEBFEK: Matlab codes and data sets for bivariate Lebesgue and Fekete interpolation.
In M. Briani, A. Sommariva, M. Vianello, Computing Fekete and Lebesgue points: simplex, square, disk we have described some algorithms for computing (quasi-)Lebesgue and (quasi-)Fekete
points on the unit simplex, a square and on the unit disk. The respective codes and sets for these domains can be found in the links below.