#include <exampleAMA_MltvGrd.h>

Functions
int	main (int argc, char **argv)
	Approximation and Interpolation of Multivariate Gridded Data More...

long int	exampleAMA_MltvGrdArguments (int argc, char *argv, long int appindx, char approx, char datfile)
	Parse main() programs parameters. More...

long int	exampleAMA_MltvGrdError (AMA_OPTIONS options, long int nind, long int ng, double *x, double z, AMA_SPLINE *spline)
	Produce absolute error table for AMA Spline Library Multivariate Gridded Data Functions. More...

long int	exampleAMA_MltvGrdWrite (AMA_OPTIONS options, const char approx, const char datname, AMA_SPLINE spline)
	Write spline approximation to ascii file. More...

Function Documentation

long int exampleAMA_MltvGrdArguments	(	int	argc,
		char **	argv,
		long int *	appindx,
		char *	approx,
		char *	datfile
	)

Parse main() programs parameters.

Parameters

argc	[in] main() program argc parameter.
argv	[in] main() program argv parameter.
appindx	[out] Approximation index.
approx	[out] Approximation function.
datfile	[out] The data file name exampleAMA_MltvGrd_datname.dat.

Returns: Success/Error Code.

Documented 111014

 {
 /* -------------------
    ... local variables
    ------------------- */
 
    const char *apptyp[5] = { "AMA_MltvGrdApprox", "AMA_MltvGrdInterp", "AMA_MltvGrdLstsqr", "AMA_MltvGrdMonoApprox", "AMA_MltvGrdMonoInterp" };
 
 /* ---------------------------------
    ... check program input arguments
    --------------------------------- */
 
    if ( argc == 3 )
    {
 /* ... check approximation type */
 
       for ( *appindx = 0; *appindx < 5; (*appindx)++ )
          if ( !strcmp ( argv[1], apptyp[*appindx] ) ) break;
 
       if ( *appindx == 5 )
       {
          fprintf ( stderr, "Invalid value of approx: Equals %s; Must be one of AMA_MltvGrdApprox, AMA_MltvGrdInterp, AMA_MltvGrdLstsqr, AMA_MltvGrdMonoApprox or AMA_MltvGrdMonoInterp.\n", argv[1] );
          return AMA_INPUT_ERROR;
       }
    }
    else
    {
       fprintf ( stderr, "Usage is exampleAMA_MltvGrd approx datfile; where approx is one of AMA_MltvGrdApprox, AMA_MltvGrdInterp, AMA_MltvGrdLstsqr, AMA_MltvGrdMonoApprox or AMA_MltvGrdMonoInterp.\n" );
       return AMA_INPUT_ERROR;
    }
 
    strcpy ( approx , argv[1] );
    strcpy ( datfile, argv[2] );
 
    return AMA_NO_ERROR;
 }

long int exampleAMA_MltvGrdError	(	AMA_OPTIONS *	options,
		long int	nind,
		long int *	ng,
		double **	x,
		double *	z,
		AMA_SPLINE *	spline
	)

Produce absolute error table for AMA Spline Library Multivariate Gridded Data Functions.

This function writes the absolute error table for AMA Spline Library functions which compute spline approximations of independent variable data ${\bf X}\in\Re^n$ and dependent variable data ${\bf Z}\in\Re^1$ to stdout. The independent variable data defines the rectilinear grid

$(x_{1,1},x_{1,2},\cdots,x_{1,N^g_1-1},x_{1,N^g_1})\times\cdots\times(x_{n,1},x_{n,2},\cdots,x_{n,N^g_n-1},x_{n,N^g_n})$

where $N^g_k\ge 2$ and $1\le k\le n$ . The dependent variable data lies on the grid and is given as $z_{\ell_1,\cdots,\ell_n}$ for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ ; that is, there are $N=\prod_{k=1}^nN^g_k$ dependent variable values. This function does the following:

Computes the value of the spline approximation, see AMA_SplineValue().
Computes $\vert s_1(x_{1,\ell_1},\cdots,x_{n,\ell_n}) - z_{\ell_1,\cdots,\ell_n}\vert$ , for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ and writes it to stdout.
Writes the minimum, maximum and sum of squares errors to stdout.

Parameter Note: In the parameter definitions given below the limits on $k$ are $1\le k\le n$ and k = $k-1$ .

Parameters

options	[in] Pointer to AMA_OPTIONS. Should be initialized with AMA_Options().
nind	[in] The number of independent variables .
ng	[in] Array of size nind containing the number of points where ng[k] .
x	[in] Array of size nind containing arrays of size ng[k] where x[k] contains the independent variable data $x_{k,\ell_k}$ , $\ell_k=1,\ldots,N^g_k$ .
z	[in] Array of size containing the dependent variable data $z_{\ell_1,\cdots,\ell_n}$ , for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ .
spline	[in] Pointer to AMA_SPLINE containing the spline approximation.

Returns: Success/Error Code

Documented 021616

 {
 /* ------------------- 
    ... local variables
    ------------------- */
 
    AMA_ERROR_INIT ( "exampleAMA_MltvGrdError" )
 
    long int jndex[AMA_MXNIND];
    long int k;
    long int l;
    long int n = 1;
 
    double abserr;
    double dbltwo = 2.0;
    double rmax = 0.0;
    double rmin = DBL_MAX;
    double sos = 0.0;
    double sval;
    double xval[AMA_MXNIND];
 
 /* --------------------------
    ... compute absolute error
    -------------------------- */
 
    for ( k = 0; k < nind; k++ ) n *= ng[k];
 
    AMA_InitializeJndex ( nind, jndex );
 
    fprintf ( stdout, "\n\n" );
 
    for ( k = 0; k < nind; k++ ) fprintf ( stdout, "        x_%ld      ", k );
    fprintf ( stdout, "        z(x)             s(x)         |s(x)-z(x)|\n  " );
 
    for ( k = 0; k < nind; k++ ) fprintf ( stdout, "---------------" );
    fprintf ( stdout, "-----------------------------------------------------\n" );
      
    for ( l = 0; l < n; l++ )
    {
       AMA_IncrementJndex ( nind, ng, jndex );
 
       for ( k = 0; k < nind; k++ ) xval[k] = x[k][jndex[k]];
       AMA_FUNCTN_ERROR ( AMA_SplineValue ( options, xval, spline, &sval ) )
 
       abserr = fabs ( sval - z[l] );
       for ( k = 0; k < nind; k++ )fprintf ( stdout, "  %15.8e", x[k][jndex[k]] );
       fprintf ( stdout, "  %15.8e  %15.8e  %15.8e\n", z[l], sval, abserr );
 
       rmin = NSPLSQ_MIN ( rmin, abserr );
       rmax = NSPLSQ_MAX ( rmax, abserr );
 
       sos += pow ( abserr, dbltwo );
    }
 
    fprintf ( stdout, "\n  Residual Summary\n" );
 
    fprintf ( stdout, "  -------------------------------\n" );
    fprintf ( stdout, "  Minimum Error:  %+15.7e\n"  , rmin );
    fprintf ( stdout, "  Maximum Error:  %+15.7e\n"  , rmax );
    fprintf ( stdout, "  Sum of Squares: %+15.7e\n\n", sos  );
 
    return AMA_SuccessErrorCode ( options, ier, inputFatal );
 }

long int exampleAMA_MltvGrdWrite	(	AMA_OPTIONS *	options,
		const char *	approx,
		const char *	datname,
		AMA_SPLINE *	spline
	)

Write spline approximation to ascii file.

This function writes a spline approximation to the ascii file datname_approx.spl.

Parameters

options	[in] Pointer to AMA_OPTIONS initialized with AMA_Options().
approx	[in] Approximation function. Should be one of AMA_MltvGrdApprox, AMA_MltvGrdInterp, AMA_MltvGrdLstsqr, AMA_MltvGrdMonoApprox or AMA_MltvGrdMonoInterp.
datname	[in] The component datname of the data file name exampleAMA_MltvGrd_datname.dat.
spline	[in] Pointer to AMA_SPLINE containing the spline approximation.

Returns: Success/Error Code

Documented 111014

 {  
 /* -------------------
    ... local variables
    ------------------- */
 
    AMA_ERROR_INIT ( "exampleAMA_MltvGrdWrite" )
 
    char splfile[AMA_MXCHAR];
 
 /* ------------------------------
    ... write spline to ascii file
    ------------------------------ */
 
    sprintf ( splfile, "%s_%s.spl", datname, approx );
 
    AMA_FUNCTN_ERROR ( AMA_SplineWrite ( options, splfile, "ascii", spline ) )
 
    return AMA_SuccessErrorCode ( options, ier, inputFatal );
 }

int main	(	int	argc,
		char **	argv
	)

Approximation and Interpolation of Multivariate Gridded Data

This program illustrates usage of the AMA Spline Library's Multivariate Gridded Data Functions which it employs to compute spline approximations of independent variable data ${\bf X}\in\Re^n$ and dependent variable data ${\bf Z}\in\Re^1$ . The independent variable data defines the rectilinear grid $(x_{1,1},x_{1,2},\cdots,x_{1,N^g_1-1},x_{1,N^g_1})\times\cdots\times(x_{n,1},x_{n,2},\cdots,x_{n,N^g_n-1},x_{n,N^g_n})$ where $N^g_k\ge 2$ and $1\le k\le n$ . The dependent variable data lies on the grid and is given as $z_{\ell_1,\cdots,\ell_n}$ for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ ; that is, there are $N=\prod_{k=1}^nN^g_k$ dependent variable values. Similarly, the approximation tolerances $\epsilon_{\ell_1,\cdots,\ell_n}$ for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ lie on the grid.

Its usage is:

exampleAMA_MltvGrd approx datfile

where approx is one of AMA_MltvGrdApprox, AMA_MltvGrdInterp, AMA_MltvGrdLstsqr, AMA_MltvGrdMonoApprox or AMA_MltvGrdMonoInterp. Based on the value of approx this program invokes one of the following five functions:

AMA_MltvGrdApprox() - Approximation of Multivariate Gridded Data,
AMA_MltvGrdInterp() - Interpolation of Multivariate Gridded Data,
AMA_MltvGrdLstsqr() - Least Squares Approximation of Multivariate Gridded Data,
AMA_MltvGrdMonoApprox() - Monotonic Approximation of Multivariate Gridded Data,
AMA_MltvGrdMonoInterp() - Monotonic Interpolation of Multivariate Gridded Data.

The argument datfile must be of the form exampleAMA_MltvGrd_datname.dat where datname is any valid string. The file consists of a data section and may contain several, optional, approximation option sections. The Data section must preceed the approximation options sections and has the following structure:

$\begin{array}{lll} {\bf Data} & & \cr {\bf Nind:}n & & \cr {\bf Degree:}d_1 & & \cr \vdots & & \cr {\bf Degree:}d_n & & \cr {\bf Ng:}N^g_1 & & \cr x_{1,1} & & \cr \vdots & & \cr x_{1,N^g_1} & & \cr {\bf Ng:}N^g_n & & \cr x_{n,1} & & \cr \vdots & & \cr x_{n,N^g_n} & & \cr {\bf Z} &{\bf Epsilon} &{\bf Wht} \cr z_{1,\cdots,1} &\epsilon_{1,\cdots,1} &w_{1,\cdots,1} \cr z_{2,\cdots,1} &\epsilon_{2,\cdots,1} &w_{2,\cdots,1} \cr \vdots &\vdots &\vdots \cr z_{N^g_1,\cdots,1} &\epsilon_{N^g_1,\cdots,1} &w_{N^g_1,\cdots,1} \cr \vdots &\vdots &\vdots \cr z_{1,\cdots,N^g_n} &\epsilon_{1,\cdots,N^g_n} &w_{1,\cdots,N^g_n} \cr z_{2,\cdots,N^g_n} &\epsilon_{2,\cdots,N^g_n} &w_{2,\cdots,N^g_n} \cr \vdots &\vdots &\vdots \cr z_{N^g_1,\cdots,N^g_n} &\epsilon_{N^g_1,\cdots,N^g_n} &w_{N^g_1,\cdots,N^g_n} \cr {\bf End\_Data} & & \cr \end{array}$

where the Epsilon and Wht columns are optional. The data must satisfy the following conditions:

$2\le n\le$ AMA_MXNIND;
$1\le d_k \le 5$ , for $1\le k\le n$ ;
$N^g_k\ge 2$ , for $1\le k\le n$ ;
the independent variable data $x_{k,\ell_k}$ , for $\ell_k=1,\cdots,N^g_k$ and $1\le k\le n$ , must be in increasing order;
the approximation tolerances must satisfy $\epsilon_{\ell_1,\cdots,\ell_n}\ge 0.0$ , for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ ;
the weights must satisfy $w_{\ell_1,\cdots,\ell_n}\ge 0.0$ , for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ .

Following the Data section may be one or more of the Bounds, Least_Squares or Monotonicity sections. If an approximation options section is not defined, then this function sets the options to their default values. See Table Approximation Options Defaults for a list of Multivariate Gridded Data Functions approximation options default values.

The Bounds section specifies the lower and upper bounds employed by AMA_MltvGrdLstsqr(). It has the following structure:

$\begin{array}{ll} {\bf Bounds} & \cr {\bf Lwrbnd:}\alpha_l &{\bf Uprbnd:}\alpha_u \cr {\bf End\_Bounds} & \cr \end{array}$

and its options must satisfy the following conditions:

$-\alpha_\infty \le \alpha_l\le \min_{\ell_1,\cdots,\ell_n}\lbrace{z_{\ell_1,\cdots,\ell_n}\rbrace}$ where $\alpha_\infty$ equals AMA_SplineInfbnd() and $\alpha_l \le \alpha_u$ ;
$\max_{\ell_1,\cdots,\ell_n}\lbrace{z_{\ell_1,\cdots,\ell_n}\rbrace} \le \alpha_u\le \alpha_\infty$ where $\alpha_\infty$ equals AMA_SplineInfbnd() and $\alpha_u \ge \alpha_l$ .

The lower bound is read as a string lwrstr and based on the value of lwrstr the value of $\alpha_l$ is set as follows:

If lwrstr equals infbnd, then $\alpha_l = -\alpha_\infty$ where $\alpha_\infty$ = AMA_SplineInfbnd(); or,
If lwrstr equals zmin , then $\alpha_l = \min_{\ell_1,\cdots,\ell_n}\lbrace{z_{\ell_1,\cdots,\ell_n}\rbrace}$ .
Otherwise, $\alpha_l =$ atof(lwrstr).

Similarly, the upper bound is read as a string uprstr and based on the value of uprstr the value of $\alpha_u$ is set as follows:

If uprstr equals infbnd, then $\alpha_u = \alpha_\infty$ where $\alpha_\infty$ = AMA_SplineInfbnd(); or,
If uprstr equals zmax , then $\alpha_u = \max_{\ell_1,\cdots,\ell_n}\lbrace{z_{\ell_1,\cdots,\ell_n}\rbrace}$ .
Otherwise, $\alpha_u =$ atof(uprstr).

The Least_Squares section specifies the approximation options and knots employed by AMA_MltvGrdLstsqr(). It has the following structure:

$\begin{array}{ll} {\bf Least\_Squares} & \cr {\bf Theta:}\theta &{\bf Minorm:}\rm minorm \cr {\bf Mlamda:}m_1 & \cr \lambda^o_{1,1} & \cr \lambda^o_{1,2} & \cr \vdots & \cr \lambda^o_{1,m_1} & \cr \vdots & \cr {\bf Mlamda:}m_n & \cr \lambda^o_{n,1} & \cr \lambda^o_{n,2} & \cr \vdots & \cr \lambda^o_{n,m_n} & \cr {\bf End\_Least\_Squares} & \cr \end{array}$

and its options must satisfy the following conditions:

$0.0\le\theta< 1.0$ ;
${\rm minorm}$ must be Enabled or Disabled;
$m_k\ge 2$ , for $1\le k\le n$ ;
the knots $\lambda^o_{k,i}$ , for $i=1,\cdots,m_k$ and $1\le k\le n$ , must be in increasing order;
$\lambda^o_{k,1} \le x_{k,1}$ and $\lambda^o_{k,m_k} \ge x_{k,N^g_k}$ , for all $1\le k\le n$ .

The Monotonicity section specifies the monotonicity constraints and continuity conditions employed by AMA_MltvGrdMonoApprox() and AMA_MltvGrdMonoInterp(). It has the the following structure:

$\begin{array}{llll} {\bf Monotonicity} & & & \cr {\bf Monpos:\rm monpos[1]} &{\bf Monneg:\rm monneg[1]} &{\bf Monzer:\rm monzer[1]} &{\bf Concnd:\rm concnd[1]} \cr \vdots &\vdots &\vdots &\vdots \cr {\bf Monpos:\rm monpos[n]} &{\bf Monneg:\rm monneg[n]} &{\bf Monzer:\rm monzer[n]} &{\bf Concnd:\rm concnd[n]} \cr {\bf End\_Monotonicity} & & & \cr \end{array}$

and its options must satisfy the following conditions:

the positive monotonicity constraint flag ${\rm monpos}[k]$ , negative monotonicity constraint flag ${\rm monneg}[k]$ and zero monotonicity constraint flag ${\rm monzer}[k]$ must be Enabled or Disabled, for $1\le k\le n$ ;
the continuity condition ${\rm concnd}[k]$ must be Full or Reduced, for $1\le k\le n$ ;

The bold keywords are case sensitive and the string values for the approximation options are case insensitive.

The data is used by all the functions; but, the weights $w_{\ell_1,\cdots,\ell_n}$ , for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ , are used only if approx equals AMA_MltvGrdLstsqr and the approximation tolerances $\epsilon_{\ell_1,\cdots,\ell_n}$ , for $\ell_1=1,\ldots,N^g_1,\cdots,\ell_n=1,\ldots,N^g_n$ , are used only if approx equals AMA_MltvGrdApprox or AMA_MltvGrdMonoApprox. The monotonicity constraint flags and continuity conditions are used if approx equals AMA_MltvGrdMonoApprox or AMA_MltvGrdMonoInterp. The knots $\lambda^o_{k,i}$ , for $i=1,\cdots,m_k$ and $1\le k\le n$ , lower bound $\alpha_l$ , upper bound $\alpha_u$ , penalty term weight $\theta$ and the minimum norm optimization flag are used only if approx equals AMA_MltvLstsqr.

This program does the following:

Parses its arguments, see exampleAMA_MltvGrdArguments().
Reads data and approximation options, see AMA_MltvGrdData().
Computes spline approximation based on value of approx.
Produces absolute error table, see exampleAMA_MltvGrdError().
Writes spline approximation to an ascii file, see exampleAMA_MltvGrdWrite().
Writes VisIt files, see AMA_VisitMltvGrd().

Returns: 0 if successfull; 1 otherwise.

Note: If this program fails it does not free its internal memory.

Documented 110215

 {
 /* -------------------
    ... local variables
    ------------------- */
 
    char approx[AMA_MXCHAR];
    char datfile[AMA_MXCHAR];
    char datname[AMA_MXCHAR];
 
    long int appindx;
 
 /* -----------------------------
    ... data and spline variables
    ----------------------------- */
 
    AMA_OPTIONS *options = NULL;
 
    long int degree[AMA_MXNIND];
    long int ng[AMA_MXNIND];
    long int mlamda[AMA_MXNIND];
 
    long int nind;
 
    double  *epsilon = NULL;
    double **lamda = NULL;
    double   theta = 0.0;
    double  *wht = NULL;
    double **x = NULL;
    double  *z = NULL;
 
    AMA_SPLINE *spline = NULL;
 
 /* ---------------
    ... check usage
    --------------- */
 
    if ( exampleAMA_MltvGrdArguments ( argc, argv, &appindx, approx, datfile ) ) exit(1);
 
 /* ---------------------------------------
    ... allocate and initialize AMA_OPTIONS
    --------------------------------------- */
 
    if ( AMA_Options ( &options ) )
    {
       fprintf ( stderr, "  exampleAMA_MltvGrd: Error initializing AMA_OPTIONS.\n" );
       exit(1);
    }
 
 /* -------------
    ... read data 
    ------------- */
 
 /* ... check data file name */
 
    if ( AMA_DataFile ( options, datfile, "exampleAMA_MltvGrd_", datname ) )
    {
       fprintf ( stderr, "  exampleAMA_MltvGrd: Invalid data file name.\n" );
       exit(1);
    }
 
 /* ... read data */
 
    if ( AMA_MltvGrdData ( options, datfile, &nind, degree, ng, &x, &z, &epsilon, &wht, &theta, mlamda, &lamda ) )
    {
       fprintf ( stderr, "  exampleAMA_MltvGrd: Error reading data.\n" );
       exit(1);
    }
 
 /* ------------------
    ... enable options
    ------------------ */
 
 /* ... enable output */
 
    AMA_OptionsSetOutputFlag ( options, 1 );
 
 /* ... write options */
 
    if ( AMA_OptionsWrite ( options ) )
    {
       fprintf ( stderr, "Error writing AMA_OPTIONS.\n" );
       exit(1);
    }
 
 /* --------------------------------------------
    ... call user specified multivariate routine 
    -------------------------------------------- */
 
    switch ( appindx )
    {
       case 0:
          AMA_MltvGrdApprox ( options, nind, ng, x, z, epsilon, degree, &spline );
          break;
 
       case 1:
          AMA_MltvGrdInterp ( options, nind, ng, x, z, degree, &spline );
          break;
 
       case 2:
          AMA_MltvGrdLstsqr ( options, nind, ng, x, z, wht, degree, mlamda, lamda, theta, &spline );
          break;
 
       case 3:
          AMA_MltvGrdMonoApprox ( options, nind, ng, x, z, epsilon, degree, &spline );
          break;
 
       case 4:
          AMA_MltvGrdMonoInterp ( options, nind, ng, x, z, degree, &spline );
          break;
    }
 
 /* -----------------------------------------------------------
    ... write absolute error table, VisIt files and spline file
    ----------------------------------------------------------- */
 
    if ( options->ier == AMA_NO_ERROR || options->ier == AMA_PROCESS_ERROR || options->ier == AMA_WARNING_ERROR )
    {
      if ( exampleAMA_MltvGrdError ( options, nind, ng, x, z, spline ) )
       {
          fprintf ( stderr, "  exampleAMA_MltvGrd: Error writing error table.\n" );
          exit(1);
       }
 
       if ( exampleAMA_MltvGrdWrite ( options, approx, datname, spline ) )
       {
          fprintf ( stderr, "  exampleAMA_MltvGrd: Error writing spline file.\n" );
          exit(1);
       }
 
       if ( AMA_VisitMltvGrd ( options, approx, datname, nind, ng, x, z, spline ) )
       {
          fprintf ( stderr, "  exampleAMA_MltvGrd: Error writing VisIt files.\n" );
          exit(1);
       }
 
       if ( AMA_SplineFree ( options, &spline ) )
       {
          fprintf ( stderr, "  exampleAMA_MltvGrd: Error freeing spline.\n" );
          exit(1);
       }      
    }
    else
    {
       fprintf ( stderr, "  exampleAMA_MltvGrd: Approximation failed: ier = %ld\n", options->ier );
       exit(1);
    }
 
 /* -------------
    ... free data
    ------------- */
    
    if ( AMA_MltvDataFree ( options, nind, &x, &z, &epsilon, &wht, &lamda ) )
    {
       fprintf ( stderr, "  exampleAMA_MltvGrd: Error freeing data.\n" );
       exit(1);
    }
 
    if ( AMA_OptionsFree ( &options ) )
    {
       fprintf ( stderr, "  exampleAMA_MltvGrd: Error freeing AMA_OPTIONS.\n" );
       exit(1);
    }
 
    exit(0);
 }