debian/0000755000000000000000000000000012127003607007164 5ustar debian/compat0000644000000000000000000000000212126762420010366 0ustar 9 debian/libeinspline-dev.doc-base0000644000000000000000000000041412126775645014034 0ustar Document: einspline Title: Einspline Reference Documentation Author: Kenneth P. Esler, Jr. Section: Science/Mathematics Format: HTML Index: /usr/share/doc/libeinspline-dev/doc.shtml Files: /usr/share/doc/libeinspline-dev/*.shtml /usr/share/doc/libeinspline-dev/*.png debian/control0000644000000000000000000000543212127003107010566 0ustar Source: einspline Priority: extra Maintainer: Debian Science Team Uploaders: Sébastien Villemot Build-Depends: debhelper (>= 9), dh-exec, dh-autoreconf, gfortran, libfftw3-dev, pkg-config Standards-Version: 3.9.4 Section: libs Homepage: http://einspline.sourceforge.net/ Vcs-Git: git://git.debian.org/git/debian-science/packages/einspline.git Vcs-Browser: http://git.debian.org/?p=debian-science/packages/einspline.git Package: libeinspline0 Architecture: any Multi-Arch: same Pre-Depends: ${misc:Pre-Depends} Depends: ${shlibs:Depends}, ${misc:Depends} Description: library for interpolating cubic basis splines (shared library) Einspline is intended to be a simple, fast, and accurate library for creating and evaluating interpolating cubic basis splines (B-splines). . It features the following: - grids of one, two or three dimensions - both uniform and non-uniform grids - real and complex datatypes in single or double precision - evaluation of value, gradient, hessian and laplacian - periodic, fixed first-derivative, or fixed second derivative boundary conditions - C and Fortran 77 interfaces . This package contains a shared version of the library. Package: libeinspline-dev Section: libdevel Architecture: any Multi-Arch: same Depends: libeinspline0 (= ${binary:Version}), libfftw3-dev, ${misc:Depends} Description: library for interpolating cubic basis splines (static library and doc) Einspline is intended to be a simple, fast, and accurate library for creating and evaluating interpolating cubic basis splines (B-splines). . It features the following: - grids of one, two or three dimensions - both uniform and non-uniform grids - real and complex datatypes in single or double precision - evaluation of value, gradient, hessian and laplacian - periodic, fixed first-derivative, or fixed second derivative boundary conditions - C and Fortran 77 interfaces . This package contains a static version of the library and its documentation. Package: libeinspline-dbg Section: debug Architecture: any Depends: libeinspline0 (= ${binary:Version}), ${misc:Depends} Description: library for interpolating cubic basis splines (debugging symbols) Einspline is intended to be a simple, fast, and accurate library for creating and evaluating interpolating cubic basis splines (B-splines). . It features the following: - grids of one, two or three dimensions - both uniform and non-uniform grids - real and complex datatypes in single or double precision - evaluation of value, gradient, hessian and laplacian - periodic, fixed first-derivative, or fixed second derivative boundary conditions - C and Fortran 77 interfaces . This package contains the detached debugging symbols of the library. debian/changelog0000644000000000000000000000024312127003510011026 0ustar einspline (0.9.2-1) unstable; urgency=low * Initial release. (Closes: #704545) -- Sébastien Villemot Wed, 03 Apr 2013 12:41:09 +0200 debian/rules0000755000000000000000000000042112126774325010254 0ustar #!/usr/bin/make -f %: dh $@ --parallel --with autoreconf override_dh_auto_configure: dh_auto_configure -- --enable-portable-binary --enable-pthread --enable-blips override_dh_strip: dh_strip --dbg-package=libeinspline-dbg override_dh_compress: dh_compress -X.shtml debian/libeinspline-dev.docs0000644000000000000000000000002612126773714013301 0ustar www/*.shtml www/*.png debian/copyright0000644000000000000000000000221512126777657011145 0ustar Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: einspline Upstream-Contact: Kenneth P. Esler, Jr. Source: http://einspline.sourceforge.net/ Files: * Copyright: 2007 Kenneth P. Esler, Jr. License: GPL-2+ Files: debian/* Copyright: 2013 Sébastien Villemot License: GPL-2+ License: GPL-2+ 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, see . . On Debian systems, the complete text of the GNU General Public License, version 2, can be found in the file `/usr/share/common-licenses/GPL-2'. debian/watch0000644000000000000000000000007212127000371010207 0ustar version=3 http://sf.net/einspline/einspline-(.+)\.tar\.gz debian/libeinspline0.install0000755000000000000000000000010512126764434013323 0ustar #!/usr/bin/dh-exec usr/lib/${DEB_HOST_MULTIARCH}/libeinspline.so.0* debian/libeinspline-dev.install0000755000000000000000000000025512126764354014026 0ustar #!/usr/bin/dh-exec usr/include/einspline usr/lib/${DEB_HOST_MULTIARCH}/libeinspline.a usr/lib/${DEB_HOST_MULTIARCH}/libeinspline.so usr/lib/${DEB_HOST_MULTIARCH}/pkgconfig debian/patches/0000755000000000000000000000000012126777366010636 5ustar debian/patches/series0000644000000000000000000000005012126777073012041 0ustar missing-doc.patch fix-html-errors.patch debian/patches/fix-html-errors.patch0000644000000000000000000000231312126777277014721 0ustar Description: Fix some HTML errors Author: Sébastien Villemot Forwarded: no Last-Update: 2013-04-03 --- This patch header follows DEP-3: http://dep.debian.net/deps/dep3/ --- a/www/UBinterface.shtml +++ b/www/UBinterface.shtml @@ -92,7 +92,7 @@

Data to be interpolated

The data to be interpolated should have -Nx Ny Nz contiguous +Nx Ny Nz contiguous elements, arranged is row-order (C-style) format. That is, the offset of the (ix,iy,iz) element is (ix*(Ny+iy)*Nz+iz). Complex numbers are stored in the standard format of (real,imaginary) pairs, which the --- a/www/multiUBinterface.shtml +++ b/www/multiUBinterface.shtml @@ -118,7 +118,7 @@

Data to be interpolated

The data to be interpolated should have -Nx Ny Nz contiguous +Nx Ny Nz contiguous elements, arranged is row-order (C-style) format. That is, the offset of the (ix,iy,iz) element is (ix*(Ny+iy)*Nz+iz). Complex numbers are stored in the standard format of (real,imaginary) pairs, which the debian/patches/missing-doc.patch0000644000000000000000000021512612126777366014102 0ustar Description: Add back some missing HTML pages Origin: http://einspline.sourceforge.net/multiUBinterface.shtml http://einspline.sourceforge.net/F77multi.shtml Forwarded: no Last-Update: 2013-04-03 --- This patch header follows DEP-3: http://dep.debian.net/deps/dep3/ --- /dev/null +++ b/www/F77multi.shtml @@ -0,0 +1,631 @@ + + + + einspline + + + + +
+ +
+ + + +

Fortran 77 interface for multiple uniform splines

+The Fortran 77 wrappers provide a very similar interface to the +einspline library as in C, with a few exceptions: +
    +
  • The fortran routine names are the C names, prefixed by an "f".
    • +
  • The spline object pointers are passed as INTEGER*8 arguments, + to ensure proper functioning on 64-bit platforms.
    • +
  • Since F77 has no concept of structures, uniform grid objects + have been replaced by extra parameters to the + create_Multi_Ubspline_x routines. +
  • For 2D and 3D splines, data is assumed to be stored in + contiguous, row-order format (C-style). If the data is statically + allocated in F77, care must be take to ensure all element data is + contiguous in memory. +
+ + + + + + + + +
Boundary condition type Code Meaning
PERIODIC 0 Use periodic boundary conditions. The value, first + derivative and second derivative at the left boundary match + those at the right boundary.
DERIV1 1 The value of the first derivative is specified in lVal or rVal.
DERIV2 2 The value of the second derivative is specified in lVal or rVal.
FLAT 3 The value of the first derivative is set to zero at the boundary.
NATURAL 4 The value of the second derivative is set to zero at the boundary.
ANTIPERIODIC 5 Use anti-periodic boundary conditions. The value, first derivative + and second derivative at the left boundary are the negative of those + at the right boundary.
+Please see the documentation for the C routines for more information. +The subroutine names and parameters are given below: +

+

Uniform spline creation routines

+

One-dimensional:

+

Single-precision real

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_1D_S (x0, x1, num_x, x0_code, x0_val, 
+                                        x1_code, x1_val, num_splines, spline)
+
+ + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First grid point
x1 IN REAL*8 Last grid point
num_x IN INTEGER # of grid points
x0_code IN INTEGER Left BC type
x0_val IN REAL*4 Left BC value
x1_code IN INTEGER Right BC type
x1_val IN REAL*4 Right BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_1D_S (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN REAL*4 Data to interpolate
+
+

Double-precision real

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_1D_D (x0, x1, num_x, x0_code, x0_val, 
+                                        x1_code, x1_val, num_splines, spline)
+
+ + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First grid point
x1 IN REAL*8 Last grid point
num_x IN INTEGER # of grid points
x0_code IN INTEGER Left BC type
x0_val IN REAL*8 Left BC value
x1_code IN INTEGER Right BC type
x1_val IN REAL*8 Right BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_1D_D (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN REAL*8 Data to interpolate
+
+

Single-precision complex

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_1D_C (x0, x1, num_x, x0_code, x0_val, 
+                                        x1_code, x1_val, num_splines, spline)
+
+ + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First grid point
x1 IN REAL*8 Last grid point
num_x IN INTEGER # of grid points
x0_code IN INTEGER Left BC type
x0_val IN COMPLEX*8 Left BC value
x1_code IN INTEGER Right BC type
x1_val IN COMPLEX*8 Right BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_1D_C (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN COMPLEX*8 Data to interpolate
+
+

Double-precision complex

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_1D_Z (x0, x1, num_x, x0_code, x0_val, 
+                                        x1_code, x1_val, num_splines, spline)
+
+ + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First grid point
x1 IN REAL*8 Last grid point
num_x IN INTEGER # of grid points
x0_code IN INTEGER Left BC type
x0_val IN COMPLEX*16 Left BC value
x1_code IN INTEGER Right BC type
x1_val IN COMPLEX*16 Right BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_1D_Z (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN COMPLEX*16 Data to interpolate
+ +

Two-dimensional:

+

Single-precision real

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_2D_S (x0, x1, num_x, y0, y1, num_y, 
+                                        x0_code, x0_val, x1_code, x1_val, 
+			    	        y0_code, y0_val, y1_code, y1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
x0_code IN INTEGER Left x BC type
x0_val IN REAL*4 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN REAL*4 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN REAL*4 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN REAL*4 Right y BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_2D_S (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN REAL*4 Data to interpolate
+
+

Double-precision real

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_2D_D (x0, x1, num_x, y0, y1, num_y, 
+                                        x0_code, x0_val, x1_code, x1_val, 
+				        y0_code, y0_val, y1_code, y1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
x0_code IN INTEGER Left x BC type
x0_val IN REAL*8 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN REAL*8 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN REAL*8 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN REAL*8 Right y BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_2D_D (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN REAL*8 Data to interpolate
+
+

Single-precision complex

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_2D_C (x0, x1, num_x, y0, y1, num_y, 
+                                        x0_code, x0_val, x1_code, x1_val, 
+				        y0_code, y0_val, y1_code, y1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
x0_code IN INTEGER Left x BC type
x0_val IN COMPLEX*8 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN COMPLEX*8 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN COMPLEX*8 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN COMPLEX*8 Right y BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_2D_C (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN COMPLEX*8 Data to interpolate
+
+

Double-precision complex

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_2D_Z (x0, x1, num_x, y0, y1, num_y, 
+                                        x0_code, x0_val, x1_code, x1_val, 
+				        y0_code, y0_val, y1_code, y1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
x0_code IN INTEGER Left x BC type
x0_val IN COMPLEX*16 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN COMPLEX*16 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN COMPLEX*16 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN COMPLEX*16 Right y BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_2D_Z (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN COMPLEX*16 Data to interpolate
+
+ +

Three-dimensional:

+

Single-precision real

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_3D_S (x0, x1, num_x, y0, y1, num_y, z0, z1, num_z,
+                                        x0_code, x0_val, x1_code, x1_val, 
+				        y0_code, y0_val, y1_code, y1_val, 
+				        z0_code, z0_val, z1_code, z1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
z0 IN REAL*8 First z grid point
z1 IN REAL*8 Last z grid point
num_z IN INTEGER # of z grid points
x0_code IN INTEGER Left x BC type
x0_val IN REAL*4 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN REAL*4 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN REAL*4 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN REAL*4 Right y BC value
z0_code IN INTEGER Left z BC type
z0_val IN REAL*4 Left z BC value
z1_code IN INTEGER Right z BC type
z1_val IN REAL*4 Right z BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+
+SUBROUTINE FSET_MULTI_UBSPLINE_3D_S (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN REAL*4 Data to interpolate
+
+

Double-precision real

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_3D_D (x0, x1, num_x, y0, y1, num_y, z0, z1, num_z,
+                                        x0_code, x0_val, x1_code, x1_val, 
+				        y0_code, y0_val, y1_code, y1_val, 
+				        z0_code, z0_val, z1_code, z1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
z0 IN REAL*8 First z grid point
z1 IN REAL*8 Last z grid point
num_z IN INTEGER # of z grid points
x0_code IN INTEGER Left x BC type
x0_val IN REAL*8 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN REAL*8 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN REAL*8 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN REAL*8 Right y BC value
z0_code IN INTEGER Left z BC type
z0_val IN REAL*8 Left z BC value
z1_code IN INTEGER Right z BC type
z1_val IN REAL*8 Right z BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+SUBROUTINE FSET_MULTI_UBSPLINE_3D_D (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN REAL*8 Data to interpolate
+
+

Single-precision complex

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_3D_C (x0, x1, num_x, y0, y1, num_y, z0, z1, num_z,
+                                        x0_code, x0_val, x1_code, x1_val, 
+				        y0_code, y0_val, y1_code, y1_val, 
+				        z0_code, z0_val, z1_code, z1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
z0 IN REAL*8 First z grid point
z1 IN REAL*8 Last z grid point
num_z IN INTEGER # of z grid points
x0_code IN INTEGER Left x BC type
x0_val IN COMPLEX*8 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN COMPLEX*8 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN COMPLEX*8 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN COMPLEX*8 Right y BC value
z0_code IN INTEGER Left z BC type
z0_val IN COMPLEX*8 Left z BC value
z1_code IN INTEGER Right z BC type
z1_val IN COMPLEX*8 Right z BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+SUBROUTINE FSET_MULTI_UBSPLINE_3D_C (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN COMPLEX*8 Data to interpolate
+
+

Double-precision complex

+
+SUBROUTINE FCREATE_MULTI_UBSPLINE_3D_Z (x0, x1, num_x, y0, y1, num_y, z0, z1, num_z,
+                                        x0_code, x0_val, x1_code, x1_val, 
+				        y0_code, y0_val, y1_code, y1_val, 
+				        z0_code, z0_val, z1_code, z1_val, 
+                                        num_splines, spline)
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +
Argument Intent Type Description
x0 IN REAL*8 First x grid point
x1 IN REAL*8 Last x grid point
num_x IN INTEGER # of x grid points
y0 IN REAL*8 First y grid point
y1 IN REAL*8 Last y grid point
num_y IN INTEGER # of y grid points
z0 IN REAL*8 First z grid point
z1 IN REAL*8 Last z grid point
num_z IN INTEGER # of z grid points
x0_code IN INTEGER Left x BC type
x0_val IN COMPLEX*16 Left x BC value
x1_code IN INTEGER Right x BC type
x1_val IN COMPLEX*16 Right x BC value
y0_code IN INTEGER Left y BC type
y0_val IN COMPLEX*16 Left y BC value
y1_code IN INTEGER Right y BC type
y1_val IN COMPLEX*16 Right y BC value
z0_code IN INTEGER Left z BC type
z0_val IN COMPLEX*16 Left z BC value
z1_code IN INTEGER Right z BC type
z1_val IN COMPLEX*16 Right z BC value
num_splines IN INTEGER # of splines to interpolate
spline OUT INTEGER*8 Handle for spline object
+
+SUBROUTINE FSET_MULTI_UBSPLINE_3D_Z (spline, spline_num, data)
+
+ + + + + +
Argument Intent Type Description
spline IN INTEGER*8 Handle for spline object
spline_num IN INTEGER Spline index (0 to N-1)
data IN COMPLEX*16 Data to interpolate
+
+

Spline destruction routine

+

The following subroutine can be used to deallocate the memory for any Bspline object. +Note that in the nonuniform case, the grid objects must be destroyed after the splines that +refer to them. +

+SUBROUTINE FDESTROY_BSPLINE (spline)
+ + + +
Argument Intent Type Description
spline IN INTEGER*8 Spline object handle
+
+ +

Multiple, uniform spline evalulation routines

+The evaluation routines for the multi-spline functions are very similiar to the single +spline routines, but take arrays for the output arguments rather than single +values. Below, N in the number of splines in the multi-spline object and +D is the dimensionality (i.e. 1,2, or 3). + +

One-dimensional

+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_S     (spline, x, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_D     (spline, x, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_C     (spline, x, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_Z     (spline, x, val)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_S_VG  (spline, x, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_D_VG  (spline, x, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_C_VG  (spline, x, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_Z_VG  (spline, x, val, grad)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_S_VGL (spline, x, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_D_VGL (spline, x, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_C_VGL (spline, x, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_Z_VGL (spline, x, val, grad, lapl)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_S_VGH (spline, x, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_D_VGH (spline, x, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_C_VGH (spline, x, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_1D_Z_VGH (spline, x, val, grad, hess)
+
+ + + + + + + + + +
Argument Dimension Intent _S Type _D Type _C Type _Z Type Description
spline IN INTEGER*8 INTEGER*8 INTEGER*8 INTEGER*8 Spline handle
x IN REAL*8 REAL*8 REAL*8 REAL*8 Interpolation position
val N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated value
grad D*N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated first derivative
lapl N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated second derivative
hess D*D*N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated second derivative
+
+ +

Two-dimensional

+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_S     (spline, x, y, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_D     (spline, x, y, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_C     (spline, x, y, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_Z     (spline, x, y, val)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_S_VG  (spline, x, y, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_D_VG  (spline, x, y, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_C_VG  (spline, x, y, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_Z_VG  (spline, x, y, val, grad)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_S_VGL (spline, x, y, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_D_VGL (spline, x, y, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_C_VGL (spline, x, y, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_Z_VGL (spline, x, y, val, grad, lapl)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_S_VGH (spline, x, y, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_D_VGH (spline, x, y, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_C_VGH (spline, x, y, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_2D_Z_VGH (spline, x, y, val, grad, hess)
+
+ + + + + + + + + + +
Argument Dimension Intent _S Type _D Type _C Type _Z Type Description
spline IN INTEGER*8 INTEGER*8 INTEGER*8 INTEGER*8 Spline handle
x IN REAL*8 REAL*8 REAL*8 REAL*8 x coordinate for interpolation
y IN REAL*8 REAL*8 REAL*8 REAL*8 y coordinate for interpolation
val N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated value
grad D*N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated gradient (2 elements)
lapl N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated Laplacian
hess D*D*N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated Hessian (4 elements)
+
+ +

Three-dimensional

+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_S     (spline, x, y, z, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_D     (spline, x, y, z, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_C     (spline, x, y, z, val)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_Z     (spline, x, y, z, val)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_S_VG  (spline, x, y, z, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_D_VG  (spline, x, y, z, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_C_VG  (spline, x, y, z, val, grad)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_Z_VG  (spline, x, y, z, val, grad)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_S_VGL (spline, x, y, z, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_D_VGL (spline, x, y, z, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_C_VGL (spline, x, y, z, val, grad, lapl)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_Z_VGL (spline, x, y, z, val, grad, lapl)
+
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_S_VGH (spline, x, y, z, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_D_VGH (spline, x, y, z, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_C_VGH (spline, x, y, z, val, grad, hess)
+SUBROUTINE FEVAL_MULTI_UBSPLINE_3D_Z_VGH (spline, x, y, z, val, grad, hess)
+
+ + + + + + + + + + + +
Argument Dimension Intent _S Type _D Type _C Type _Z Type Description
spline IN INTEGER*8 INTEGER*8 INTEGER*8 INTEGER*8 Spline handle
x IN REAL*8 REAL*8 REAL*8 REAL*8 x coordinate for interpolation
y IN REAL*8 REAL*8 REAL*8 REAL*8 y coordinate for interpolation
z IN REAL*8 REAL*8 REAL*8 REAL*8 z coordinate for interpolation
val N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated value
grad D*N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated gradient (3 elements)
lapl N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated Laplacian
hess D*D*N OUT REAL*4 REAL*8 COMPLEX*8 COMPLEX*16 Interpolated Hessian (9 elements)
+
+
+ + + + + +
SourceForge.net Logo
+ + + --- /dev/null +++ b/www/multiUBinterface.shtml @@ -0,0 +1,488 @@ + + + + einspline + + + + +
+ +
+ + + +

Multiple uniform splines

+

Spline creation

+When evaluating many splines at the same point (such as in filling in a +row of a determinant matrix in quantum Monte Carlo calculations), a +signficant speedup can be achieved by using the multiple spline +version of the uniform B-spline routines. The creation routines are +similar to those for the single splines, which the total number of splines +is passed and the raw data is NOT passed in at time of creation. + +Rather, we can the create_multi_UBspline_* routine +to allocate the memory for the splines. We then call the +set_multi_UBspline_* routine for +each spline, passing the the spline index and the raw data +to be interpolated. + +

Base data types

+Each spline creation and evaluation routines have four versions, +corresponding to the four support base data types. Following the +LAPACK naming convention, these types are specified by single-letter +codes: +
    +
  • s: single-precision real (float)
    • +
  • d: double-precision real (double)
    • +
  • c: single-precision complex (complex_float)
    • +
  • z: double-precision complex + (complex_double)
    • +
+

Grid dimensions

+The uniform grid structure, has the following elements, which must be specified: +
    +
  • double start : + the first grid point
    • +
  • double end : + the last grid point
    • +
  • int num : + the number of grid points
    • +
+

Boundary conditions

+The boundary conditions at the first and last grid point must be specified. They are +specifed with BCtype_x structures, where x is one of {s, +d, c, z}, as described above. For the real types (s and d) the +structure contains the following elements + + + + + + + + +
Type Name Description
bc_code lCode "left" boundary condition code
bc_code lCode "right" boundary condition code
d_type lVal "left" boundary condition value
d_type rVal "right" boundary condition value
BCtype_s and BCtype_d data structure elements
+ +For the complex types, we must specify both the real and imaginary +parts: + + + + + + + + + + +
Type Name Description
bc_code lCode "left" boundary condition code
bc_code lCode "right" boundary condition code
d_type lVal_r "left" boundary condition real part
d_type lVal_i "left" boundary condition imag part
d_type rVal_r "right" boundary condition real part
d_type rVal_i "right" boundary condition imag part
BCtype_s and BCtype_d data structure elements
+
+lCode and lVal specify the boundary conditions +at the first grid point (the "left" boundary), while rCode and +rVal specify the boundary conditions on the last grid point (the "right" +boundary).
+bc_code is one of the enumerated value, +{PERIODIC, DERIV1, +DERIV2, FLAT, +NATURAL, ANTIPERIODIC }.
+d_type is the the C type corresponding to +{s, d, c, z}, i.e. {float, double, complex_float, complex_double} +

+The codes have the following meaning + + + + + + + + +
Code Meaning
PERIODIC Use periodic boundary conditions. The value, first derivative and second derivative at the left +boundary match those at the right boundary.
DERIV1 The value of the first derivative is specified in lVal or rVal.
DERIV2 The value of the second derivative is specified in lVal or rVal.
FLAT The value of the first derivative is set to zero at the boundary.
NATURAL The value of the second derivative is set to zero at the boundary.
ANTIPERIODIC Use anti-periodic boundary conditions. The value, first derivative and second derivative at the left +boundary are the negative of those at the right boundary.
+ + + +

Data to be interpolated

+The data to be interpolated should have +Nx Ny Nz contiguous +elements, arranged is row-order (C-style) format. That is, the offset +of the (ix,iy,iz) element is (ix*(Ny+iy)*Nz+iz). Complex numbers are +stored in the standard format of (real,imaginary) pairs, which the +real element first. + +

Function prototypes:

+Single-precision real:
+
+multi_UBspline_1d_s * create_multi_UBspline_1d_s (Ugrid x_grid, BCtype_s xBC, int num_splines);
+multi_UBspline_2d_s * create_multi_UBspline_2d_s (Ugrid x_grid, Ugrid y_grid,
+                                                  BCtype_s xBC, BCtype_s yBC, int num_splines);
+multi_UBspline_3d_s * create_multi_UBspline_3d_s (Ugrid x_grid,   Ugrid y_grid, Ugrid z_grid,
+                                                  BCtype_s  xBC,  BCtype_s   yBC, BCtype_s   zBC, int num_splines);
+
+void set_multi_UBspline_1d_s (multi_UBspline_1d_s* spline, int spline_num, float *data);
+void set_multi_UBspline_2d_s (multi_UBspline_2d_s* spline, int spline_num, float *data);
+void set_multi_UBspline_3d_s (multi_UBspline_3d_s* spline, int spline_num, float *data);
+
+
+Single-precision complex:
+
+multi_UBspline_1d_c * create_multi_UBspline_1d_c (Ugrid x_grid, BCtype_c xBC, int num_splines);
+multi_UBspline_2d_c * create_multi_UBspline_2d_c (Ugrid x_grid, Ugrid y_grid,
+                                                  BCtype_c xBC, BCtype_c yBC, int num_splines);
+multi_UBspline_3d_c * create_multi_UBspline_3d_c (Ugrid x_grid,   Ugrid y_grid, Ugrid z_grid,
+                                                  BCtype_c  xBC,  BCtype_c   yBC, BCtype_c   zBC, 
+                                                  int num_splines);
+
+void set_multi_UBspline_1d_c (multi_UBspline_1d_c* spline, int spline_num, complex_float *data);
+void set_multi_UBspline_2d_c (multi_UBspline_2d_c* spline, int spline_num, complex_float *data);
+void set_multi_UBspline_3d_c (multi_UBspline_3d_c* spline, int spline_num, complex_float *data);
+
+
+Double-precision real:
+
+multi_UBspline_1d_d * create_multi_UBspline_1d_d (Ugrid x_grid, BCtype_d xBC, int num_splines);
+multi_UBspline_2d_d * create_multi_UBspline_2d_d (Ugrid x_grid, Ugrid y_grid,
+                                                  BCtype_d xBC, BCtype_d yBC, int num_splines);
+multi_UBspline_3d_d * create_multi_UBspline_3d_d (Ugrid x_grid,   Ugrid y_grid, Ugrid z_grid,
+                                                  BCtype_d  xBC,  BCtype_d   yBC, BCtype_d   zBC, int num_splines);
+
+void set_multi_UBspline_1d_d (multi_UBspline_1d_d* spline, int spline_num, double *data);
+void set_multi_UBspline_2d_d (multi_UBspline_2d_d* spline, int spline_num, double *data);
+void set_multi_UBspline_3d_d (multi_UBspline_3d_d* spline, int spline_num, double *data);
+
+
+ Double-precision complex:
+
+multi_UBspline_1d_z * create_multi_UBspline_1d_z (Ugrid x_grid, BCtype_z xBC, int num_splines);
+multi_UBspline_2d_z * create_multi_UBspline_2d_z (Ugrid x_grid, Ugrid y_grid,
+                                                  BCtype_z xBC, BCtype_z yBC, int num_splines);
+multi_UBspline_3d_z * create_multi_UBspline_3d_z (Ugrid x_grid,   Ugrid y_grid, Ugrid z_grid,
+                                                  BCtype_z  xBC,  BCtype_z   yBC, BCtype_z   zBC, 
+                                                  int num_splines);
+
+void set_multi_UBspline_1d_z (multi_UBspline_1d_z* spline, int spline_num, complex_double *data);
+void set_multi_UBspline_2d_z (multi_UBspline_2d_z* spline, int spline_num, complex_double *data);
+void set_multi_UBspline_3d_z (multi_UBspline_3d_z* spline, int spline_num, complex_double *data);
+
+
+
+

Spline destruction

+The memory used for spline storage can be freed simply by a call to +
+void
+destroy_Bspline (void *spline);
+
+The spline parameter can be a spline of any type and dimension, +uniform or nonuniform. +
+

Spline evaluation

+In contrast to the single-spline routines, eval_multi_UBspline_* routines +evaluate all num_splines splines at a given point with a single call. +The prototypes for the functions are very similar to the single-spline prototypes, but the +value, gradient, hessian, and laplacian arguments are now arrays which much be +of sufficicient size to hold the values for all the splines. If the multi-spline object +was created with N splines, the value parameter must be an array of length N. +Similarly, the gradient array must have dimension N*D, where D is the +spline dimensionality (i.e. 1, 2, or 3). Finally the hessian argument must have +dimension N*D*D. + +For each of the four datatypes, there are four evaluation routines, depending on +which quantities need to be computed: +
    +
  • Value only +
  • Value and gradient +
  • Value, gradient, and Laplacian +
  • Value, gradient, and Hessian (matrix of 2nd derivatives) +
+For consistency, all results are returned through pointers passed to the evaluation +routines. Currently, no bounds checking is done for the sake of speed. The user is +responsible for ensuring that the points passed to the evaluation functions fall within +the grids specified at the time of spline creation.
+ +

Function prototypes:

+ + + + + + + + + + + + + + + + + + + + +
Quick Jump Table 1D 2D 3D
Single-precision real 1ds + 2ds + 3ds +
Single-precision complex 1dc + 2dc + 3dc +
Double-precision real 1dd + 2dd + 3dd +
Double-precision complex 1dz + 2dz + 3dz +
+
+

Single-precision real:

+ 1D +
+inline void
+eval_multi_UBspline_1d_s     (multi_UBspline_1d_s * restrict spline, 
+		              double x, float* restrict val);
+
+inline void
+eval_multi_UBspline_1d_s_vg  (multi_UBspline_1d_s * restrict spline, double x, 
+  		              float* restrict val, float* restrict grad);
+
+inline void
+eval_multi_UBspline_1d_s_vgl (multi_UBspline_1d_s * restrict spline, double x, 
+			      float* restrict val, float* restrict grad, float* restrict lapl);
+
+inline void /* identical to above routine in 1D */
+eval_multi_UBspline_1d_s_vgh (multi_UBspline_1d_s * restrict spline, double x, 
+			      float* restrict val, float* restrict grad, float* restrict hess);
+
+ + 2D +
+inline void
+eval_multi_UBspline_2d_s     (multi_UBspline_2d_s * restrict spline, double x, double y, 
+                              float* restrict val);
+
+inline void
+eval_multi_UBspline_2d_s_vg  (multi_UBspline_2d_s * restrict spline, double x, double y, 
+  	    	              float* restrict val, float* restrict grad);
+
+inline void
+eval_multi_UBspline_2d_s_vgl (multi_UBspline_2d_s * restrict spline, double x, double y,
+			      float* restrict val, float* restrict grad, float* restrict lapl);
+
+inline void 
+eval_multi_UBspline_2d_s_vgh (multi_UBspline_2d_s * restrict spline, double x, double y,
+			      float* restrict val, float* restrict grad, float* restrict hess);
+
+ 3D +
+inline void
+eval_multi_UBspline_3d_s     (multi_UBspline_3d_s * restrict spline, double x, double y, double z,
+                              float* restrict val);
+
+inline void
+eval_multi_UBspline_3d_s_vg  (multi_UBspline_3d_s * restrict spline, double x, double y, double z,
+  		              float* restrict val, float* restrict grad);
+
+inline void
+eval_multi_UBspline_3d_s_vgl (multi_UBspline_3d_s * restrict spline, double x, double y, double z,
+			      float* restrict val, float* restrict grad, float* restrict lapl);
+
+inline void 
+eval_multi_UBspline_3d_s_vgh (multi_UBspline_3d_s * restrict spline, double x, double y,
+			      float* restrict val, float* restrict grad, float* restrict hess);
+
+ +

Single-precision complex:

+ 1D +
+inline void
+eval_multi_UBspline_1d_c     (multi_UBspline_1d_c * restrict spline, 
+		              double x, complex_float* restrict val);
+
+inline void
+eval_multi_UBspline_1d_c_vg  (multi_UBspline_1d_c * restrict spline, double x, 
+  		              complex_float* restrict val, complex_float* restrict grad);
+
+inline void
+eval_multi_UBspline_1d_c_vgl (multi_UBspline_1d_c * restrict spline, double x, 
+			      complex_float* restrict val, complex_float* restrict grad, complex_float* restrict lapl);
+
+inline void /* identical to above routine in 1D */
+eval_multi_UBspline_1d_c_vgh (multi_UBspline_1d_c * restrict spline, double x, 
+			      complex_float* restrict val, complex_float* restrict grad, complex_float* restrict hess);
+
+ + 2D +
+inline void
+eval_multi_UBspline_2d_c     (multi_UBspline_2d_c * restrict spline, double x, double y, 
+                              complex_float* restrict val);
+
+inline void
+eval_multi_UBspline_2d_c_vg  (multi_UBspline_2d_c * restrict spline, double x, double y, 
+  		              complex_float* restrict val, complex_float* restrict grad);
+
+inline void
+eval_multi_UBspline_2d_c_vgl (multi_UBspline_2d_c * restrict spline, double x, double y,
+			      complex_float* restrict val, complex_float* restrict grad, complex_float* restrict lapl);
+
+inline void 
+eval_multi_UBspline_2d_c_vgh (multi_UBspline_2d_c * restrict spline, double x, double y,
+			      complex_float* restrict val, complex_float* restrict grad, complex_float* restrict hess);
+
+ 3D +
+inline void
+eval_multi_UBspline_3d_c     (multi_UBspline_3d_c * restrict spline, double x, double y, double z,
+                              complex_float* restrict val);
+
+inline void
+eval_multi_UBspline_3d_c_vg  (multi_UBspline_3d_c * restrict spline, double x, double y, double z,
+  		              complex_float* restrict val, complex_float* restrict grad);
+
+inline void
+eval_multi_UBspline_3d_c_vgl (multi_UBspline_3d_c * restrict spline, double x, double y, double z,
+			      complex_float* restrict val, complex_float* restrict grad, complex_float* restrict lapl);
+
+inline void 
+eval_multi_UBspline_3d_c_vgh (multi_UBspline_3d_c * restrict spline, double x, double y,
+			      complex_float* restrict val, complex_float* restrict grad, complex_float* restrict hess);
+
+ +

Double-precision real:

+ 1D +
+inline void
+eval_multi_UBspline_1d_d     (multi_UBspline_1d_d * restrict spline, 
+		              double x, double* restrict val);
+
+inline void
+eval_multi_UBspline_1d_d_vg  (multi_UBspline_1d_d * restrict spline, double x, 
+  		              double* restrict val, double* restrict grad);
+
+inline void
+eval_multi_UBspline_1d_d_vgl (multi_UBspline_1d_d * restrict spline, double x, 
+			      double* restrict val, double* restrict grad, double* restrict lapl);
+
+inline void /* identical to above routine in 1D */
+eval_multi_UBspline_1d_d_vgh (multi_UBspline_1d_d * restrict spline, double x, 
+			      double* restrict val, double* restrict grad, double* restrict hess);
+
+ + 2D +
+inline void
+eval_multi_UBspline_2d_d     (multi_UBspline_2d_d * restrict spline, double x, double y, 
+                              double* restrict val);
+
+inline void
+eval_multi_UBspline_2d_d_vg  (multi_UBspline_2d_d * restrict spline, double x, double y, 
+  		              double* restrict val, double* restrict grad);
+
+inline void
+eval_multi_UBspline_2d_d_vgl (multi_UBspline_2d_d * restrict spline, double x, double y,
+			      double* restrict val, double* restrict grad, double* restrict lapl);
+
+inline void 
+eval_multi_UBspline_2d_d_vgh (multi_UBspline_2d_d * restrict spline, double x, double y,
+			      double* restrict val, double* restrict grad, double* restrict hess);
+
+ 3D +
+inline void
+eval_multi_UBspline_3d_d     (multi_UBspline_3d_d * restrict spline, double x, double y, double z,
+                              double* restrict val);
+
+inline void
+eval_multi_UBspline_3d_d_vg  (multi_UBspline_3d_d * restrict spline, double x, double y, double z,
+  		              double* restrict val, double* restrict grad);
+
+inline void
+eval_multi_UBspline_3d_d_vgl (multi_UBspline_3d_d * restrict spline, double x, double y, double z,
+			      double* restrict val, double* restrict grad, double* restrict lapl);
+
+inline void 
+eval_multi_UBspline_3d_d_vgh (multi_UBspline_3d_d * restrict spline, double x, double y,
+			      double* restrict val, double* restrict grad, double* restrict hess);
+
+ +

Double-precision complex:

+ 1D +
+inline void
+eval_multi_UBspline_1d_z     (multi_UBspline_1d_z * restrict spline, 
+		              double x, complex_double* restrict val);
+
+inline void
+eval_multi_UBspline_1d_z_vg  (multi_UBspline_1d_z * restrict spline, double x, 
+  		              complex_double* restrict val, complex_double* restrict grad);
+
+inline void
+eval_multi_UBspline_1d_z_vgl (multi_UBspline_1d_z * restrict spline, double x, 
+			      complex_double* restrict val, complex_double* restrict grad, complex_double* restrict lapl);
+
+inline void /* identical to above routine in 1D */
+eval_multi_UBspline_1d_z_vgh (multi_UBspline_1d_z * restrict spline, double x, 
+			      complex_double* restrict val, complex_double* restrict grad, complex_double* restrict hess);
+
+ + 2D +
+inline void
+eval_multi_UBspline_2d_z     (multi_UBspline_2d_z * restrict spline, double x, double y, 
+                              complex_double* restrict val);
+
+inline void
+eval_multi_UBspline_2d_z_vg  (multi_UBspline_2d_z * restrict spline, double x, double y, 
+  		              complex_double* restrict val, complex_double* restrict grad);
+
+inline void
+eval_multi_UBspline_2d_z_vgl (multi_UBspline_2d_z * restrict spline, double x, double y,
+			      complex_double* restrict val, complex_double* restrict grad, complex_double* restrict lapl);
+
+inline void 
+eval_multi_UBspline_2d_z_vgh (multi_UBspline_2d_z * restrict spline, double x, double y,
+			      complex_double* restrict val, complex_double* restrict grad, complex_double* restrict hess);
+
+ 3D +
+inline void
+eval_multi_UBspline_3d_z     (multi_UBspline_3d_z * restrict spline, double x, double y, double z,
+                              complex_double* restrict val);
+
+inline void
+eval_multi_UBspline_3d_z_vg  (multi_UBspline_3d_z * restrict spline, double x, double y, double z,
+  		              complex_double* restrict val, complex_double* restrict grad);
+
+inline void
+eval_multi_UBspline_3d_z_vgl (multi_UBspline_3d_z * restrict spline, double x, double y, double z,
+			      complex_double* restrict val, complex_double* restrict grad, complex_double* restrict lapl);
+
+inline void 
+eval_multi_UBspline_3d_z_vgh (multi_UBspline_3d_z * restrict spline, double x, double y,
+			      complex_double* restrict val, complex_double* restrict grad, complex_double* restrict hess);
+
+
+
+ + + + + +
SourceForge.net Logo
+ + + debian/source/0000755000000000000000000000000012126774060010473 5ustar debian/source/format0000644000000000000000000000001412126774060011701 0ustar 3.0 (quilt)