Efficiently fitting cubic splines in SAS to specific grid of objects

Question 1

Ok. I'm going to do this for 2 data sets to help you with the fact you have a bunch. You will have to modify for your inputs, but this should give you better performance.

Create some inputs
Get the first and last values from each input data set.
Create a list of all MNES values.
Merge each input to the MNES list and set the upper and lower values.
Append the Inputs together
Run PROC EXPAND with a BY statement to single pass all the input values and create the splines.

The trick is to "trick" EXPAND into thinking MNES is a Daily timeseries. I do this by making it an integer -- date values are integers behind the scenes in SAS. With no gaps, ETS Procedures will assume a "daily" frequency.

After this is done, run a Data Step to call the Black-Scholes (BLKSHPTPRC, BLKSHCLPRC) functions and complete your analysis.

/*Sample Data*/
data input1;
input MNES    IV;
/*Make MNES and integer*/
MNES = MNES * 1000;
datalines;
 0.84  0.40
 0.89  0.34
 0.91  0.31
 0.93  0.29
 0.95  0.26
 0.98  0.23
 0.99  0.22
 1.00  0.22
 1.02  0.20
 1.04  0.18
 1.07  0.18
 ;
run;

data input2;
input MNES    IV;
MNES = MNES * 1000;
datalines;
 0.80  0.40
 0.9  0.34
 0.91  0.31
 0.93  0.29
 0.95  0.26
 0.98  0.23
 1.02  0.19
 1.04  0.18
 1.07  0.16
 ;
run;

/*Get the first and last values from the input data*/
data _null_;
set input1 end=last;
if _n_ = 1 then do;
    call symput("first1",mnes);
    call symput("first1_v",iv);
end;
if last then do;
    call symput("last1",mnes);
    call symput("last1_v",iv);
end;
run;

data _null_;
set input2 end=last;
if _n_ = 1 then do;
    call symput("first2",mnes);
    call symput("first2_v",iv);
end;
if last then do;
    call symput("last2",mnes);
    call symput("last2_v",iv);
end;
run;

/*A list of the MNES values*/
data points;
do mnes=333 to 3000;
    output;
end;
run;

/*Join Inputs to the values and set the lower and upper values*/
data input1;
merge points input1;
by mnes;
if mnes < &first1 then
    iv = &first1_v;
if mnes > &last1 then
    iv = &last1_v;

run;
data input2;
merge points input2;
by mnes;
if mnes < &first2 then
    iv = &first2_v;
if mnes > &last2 then
    iv = &last2_v;

run;

/*Append the data sets together, keep a value 
  so you can tell them apart*/
data toSpline;
set input1(in=ds1)
    input2(in=ds2);
if ds1 then
    Set=1;
else if ds2 then
    Set=2;
run;

/*PROC Expand for the spline.  The integer values
  for MNES makes it think these are "daily" data*/
proc expand data=toSpline out=outSpline method=spline;
by set;
id mnes;
run;

Question 2

Here is the solution I came up with. Sadly, I cannot yet conclude whether this is more efficient than the PROC IML solution - just for one dataset they both take the pretty much the same running time.

MSPLINT: 
real time: 1.42 seconds
cpu time 0.23 seconds

PROC IML: 
real time: 1.02 seconds
cpu time: 0.26 seconds

The biggest disadvantage of this solution when compared to the one above by @DomPazz is that I cannot process the data by 'By groups', which would certainly make it a lot faster... I am still thinking whether I can solve this without resorting to a macro loop but I am all out of ideas.

I keep the solution of defining a macro variable with the first and last values, as proposed by @DomPazz, but I then use a datastep, which copies the first and last values or applies the interpolation depending on what value of MNES it is stepping through. It applies the interpolation through the MSPLINT function. Its syntax is as follows:

MSPLINT(X, n, X1 <, X2, ..., Xn>, Y1 <,Y2, ..., Yn> <, D1, Dn>)

Where X is the object at which you wish to evaluate the spline, n is the number of knots supplied to the function (i.e. the number of observations in the input data), X1,...,Xn are the objects in the input data (i.e. MNES) and Y1,...,Yn are the images in the input data (i.e. IV). D1 and Dn (optional) are the derivatives you wish to maintain for interpolation objects X < X1 and X>Xn.

An interesting note is that by specifying D1 and Dn. as 0 you can have the points beyond the grid equal to the last observation inside the interpolated area. However, this forces the spline images to converge to a derivative of zero, potentially generating a non-natural pattern in the data. I opted not to define these as zero and defining the points outside the interpolation area separately.

So, I use PROC SQL to define the lists of elements of MNES and IV in macro variables, divided by commas, so that I can input them in the MSPLINT function. I also define the number of observations through PROC SQL.

MNES, as I commented in the answer above, was not well defined in my explanation. It needs to be defined as the variable u to the power of elements from -500 to 500. This is just a detail but it will allow you to understand where MNES comes from in the example below.

So, here is the solution, including example data.

* Set model inputs;
%let m = 500;
%let k = 2;
%let u = (1+&k) ** (1/&m);

/*Sample Data*/    
data input1;
    input MNES 13.10 IV 8.6;
    cards;
0.8444984010 0.400535
0.8901469633 0.347988
0.9129712444 0.318596
0.9357955255 0.291456
0.9586198066 0.264852
0.9814440877 0.236231
0.9928562283 0.224858
1.0042683688 0.220035
1.0270926499 0.201118
1.0499169310 0.189373
1.0727412121 0.185628
    ;
run;

data _null_;
    set input1 end=last;
    if _n_ = 1 then do;
        call symput("first1",MNES);
        call symput("first1_v",IV);
    end;
    if last then do;
        call symput("last1",MNES);
        call symput("last1_v",IV);
    end;
run;

proc sql noprint;
    select MNES into:mneslist
    separated by ','
    from input1;
    select IV into:IVlist
    separated by ','
    from input1;
    select count(*) into:countlist
    from input1;
quit;

data splined;
    do grid=-500 to 500;
        mnes = (&u) ** grid;
        if mnes < &first1 then IV = &first1_v;
        if mnes > &last1 then IV = &last1_v;
        if mnes >= &first1 and mnes <= &last1 then IV = msplint(mnes, &countlist, &mneslist, &IVlist);
    end;
run;