# ocmath_modified_shepard_interpolant

## Description

This subroutine generates a two-dimensional surface interpolating a set of scattered data points, using a modification of Shepard's method.

## Syntax

int ocmath_modified_shepard_interpolant( int npts, double * x, double * y, double * f, ocmath_ModShepard_Struct * comm, ocmath_ModShepard_Opt * optional )


## Parameters

npts
[input]number of nodes and associated data values.
npts should be larger than or equal to 6
x
[input] array of length n containing the cartesian x coordinates of the nodes
y
[input] array of length n containing the cartesian y coordinates of the nodes
f
[output]array of length n containing the data values in one-to-one correspondence with the nodes.
comm
[output] the structure contains the result and the option of the interpolation.
optional
[input] the user specified option.
optional->nq: the number of points involved in the calculation of the quadratic function.
Constraint: 5 <= nq <= min(40, m-1)
optional->nw: the number of points involved in the calculation of the weight function.
Constraint: 1 <= nw <= min(40, m-1)
When optional == NULL, the default value for nq and nw are:
optional->nq = 13;
optional->nw = 19;

## Return

Err_Intp_No_Error: No error occur;

Err_Intp_Mem_Fail: Fails to allocate memory;

Err_Intp_Method: Invalid input for interpolation method

Err_Intp_Invalid_Point: Not enough points or all points collinear

Err_Intp_Duplicate_Point: Duplicate points founded

## Examples

EX1

#include <wks2mat.h>
void ocmath_modified_shepard_interpolant_ex1()
{
double x[9] = { 0.,1.,1.,0.,.25,.5,.75,.5, 1. };
double y[9] = { 0.,0.,1.,1.,.5,.3,.5,.7 , 0.5};
double z[9] = { 0, 1, 2, 1, 0.5, 0.59, 1, 0.99, 1.25};
double px[5] = { .1,.3,.5,.7,.9 };
double py[5] = { .2,.4,.6,.8, .4 };

int n = 9;

ocmath_ModShepard_Opt optional;
ocmath_ModShepard_Struct comm;

optional.nq = 5;
optional.nw = 7;

ocmath_modified_shepard_interpolant(n, x, y, z,&comm, &optional);

int m = 5;
double pf[5];
ocmath_modified_shepard_eval(&comm, m, px, py, pf);

for(int i=0; i<m; i++)
printf("%g\t%g\t%g\n\n", px[i], py[i], pf[i]);

ocmath_modshepard_struct_free(&comm);
}


EX2

//assume there are x, y, z data in the first three columns of active worksheet
//this example will create a new matrix storing gridding data
#include <wks2mat.h>
void ocmath_modified_shepard_interpolant_ex2()
{
Worksheet    wks = Project.ActiveLayer();
if(!wks)
{
out_str("found no active worksheet");
return;
}
Dataset    dsX(wks, 0);
Dataset    dsY(wks, 1);
Dataset dsZ(wks, 2);
int npts = dsX.GetSize();
vector vX = dsX;
vector vY = dsY;
vector vZ = dsZ;

ocmath_ModShepard_Opt optional;
ocmath_ModShepard_Struct comm;

optional.nq = 5;
optional.nw = 7;

ocmath_modified_shepard_interpolant(npts, vX, vY, vZ, &comm, &optional);

//set X and Y of the gridding
double dXMin, dXMax, dYMin, dYMax;
vX.GetMinMax(dXMin, dXMax);
vY.GetMinMax(dYMin, dYMax);

//perform random matrix conversion using Kriging algorithm
int nRows = 100;
int nCols = 50;
matrix    mZ(nRows, nCols);
vector    vEvalX(nRows * nCols);
vector    vEvalY(nRows * nCols);
ocmath_mat_to_regular_xyz(NULL, nRows, nCols, dXMin, dXMax, dYMin, dYMax, vEvalX, vEvalY, NULL, true);
ocmath_modified_shepard_eval(&comm, nRows * nCols, vEvalX, vEvalY, mZ);
ocmath_modshepard_struct_free(&comm);

//create Matrix storing the result
MatrixLayer    mResultLayer;
mResultLayer.Create();
Matrix    matResult(mResultLayer);
matResult = mZ;
MatrixObject mo = mResultLayer.MatrixObjects(0);
mo.SetXY(dXMin, dYMin, dXMax, dYMax);//set X and Y range of Matrix
}