Akma interpolation (2D)

#ifndef Interpolation_Header

#define interpolation_header

#include

#include

#include

#include

Using namespace std;

#define delta 1e-6

#define very_close (x, y) Fabs ((x) - (y))

Template

Class Point2D

{

PUBLIC:

Point2D (t _x = 0, t _y = 0)

: X (_x), y (_y)

{

}

T x, y;

}

Bool Myfunc (Const Point2D & P1, Const Point2D & P2)

{

Return P1.x Delta

}

Class Point2D_X_SS_Delta

{

PUBLIC:

Template

BOOL Operator () (Const Point2D & P1, Const Point2D & P2)

{

Return P1.x Delta

}

}

Template

Ostream & Operator << (Ostream & OS, Const Point2D & P)

{

Return OS << p.X << "/ t" << p.y << endl;

}

Template

iStream & Operator >> (Ostream & IS, POINT2D & P)

{

Return IS >> P.X >> P.Y;

}

Class Interpolationsmooth

{

PUBLIC:

Interpolationsmooth () {}

Template

Interpolationsmooth (InputITerator Iter1, InputItemrator ITER2):

PTS (item1, iter2)

{

}

Void Insert (const point2d & p)

{

PTS.Insert (p);

}

Template

Void Insert (InputITerator ITER1, InputITerator ITER2)

{

PTS.Insert (item1, iter2);

}

Double getValue (double x)

{

IF (x <(* pts.begin ()). x)

{

Throw Exception ("Iuput is Too Small!");

}

Set , point2d_x_less_delta> :: item t = lower_bound (pts.begin (), pts.end (), Point2D (x, 0), myfunc);

IF (iter == pts.begin ())

{

iTer ;

}

INT K = Distance (PTS.BEGIN (), ITER);

K -;

Double Xkp1 = (* iTer) .x; item--;

Double S0 = (* ip) .y;

Double S1 = G (K);

Double S2 = (u (k) * 3-g (k) * 2-g (k 1)) / (xkp1 - (* iter) .x);

Double S3 = (g (k) g (k 1) -u (k) * 2.0) / ((xkp1 - (* iter) .x) * (xkp1 - (* iter) .x));

S1 * = X - (* iter) .x;

S2 * = (x - (* iter) .x) * (x - (* it) .x);

S3 * = (x - (* iter) .x) * (x - (* iter) .x) * (x - (* it) .x);

RETURN S0 S1 S2 S3;

}

Double GetderivativeValue (Double X)

{

IF (x <(* pts.begin ()). x)

{

Throw Exception ("Iuput is Too Small!");

}

Set , point2d_x_less_delta> :: item t = lower_bound (pts.begin (), pts.end (), Point2D (x, 0), myfunc);

IF (iter == pts.begin ())

{

iTer ;

}

INT K = Distance (PTS.BEGIN (), ITER);

K -;

Double Xkp1 = (* iter) .x;

iTer--;

Double S1 = G (K);

Double S2 = (u (k) * 3-g (k) * 2-g (k 1)) / (xkp1 - (* iter) .x);

Double S3 = (g (k) g (k 1) -u (k) * 2.0) / ((xkp1 - (* iter) .x) * (xkp1 - (* iter) .x));

S2 * = (x - (* iter) .x) * 2.0;

S3 * = (x - (* iter) .x) * (x - (* iter) .x) * 3.0;

RETURN S1 S2 S3;

}

Set , point2d_x_less_delta> :: item begin ()

{

Return PTS.BEGIN ();

}

Set , point2d_x_less_delta> :: item End ()

{

Return pts.end ();

}

SIZE_T SIZE ()

{

Return Pts.size ();

}

Private:

Double u (int _POS)

{

INT NUM = (int) (PTS.SIZE ());

IF (NUM <= 2 || _POS> NUM) throw exception ("Size is TOO SMALL!");

IF (_POS> = NUM-1)

{

Return u (_POS-1) * 2.0-U (_POS-2);

}

IF (_POS <0)

{

Return u (_POS 1) * 2.0-U (_POS 2);

}

Set , point2d_x_less_delta> :: item t1 = pts.begin ();

Set , point2d_x_less_delta> :: item = pts.begin ();

Advance (iter1, _pos);

Advance (iTer2, _POS 1);

RETURN (* iter2) .y - (* iter1) .y) / (* iter2) .x - (* iter1) .x);

}

Double G (INT _POS)

{

Double

UK

= U (_pos), ukp1 = u (_POS 1), ukm1 = u (_POS-1), ukm2 = u (_POS-2);

IF (Very_Close)

UK

, Ukp1) && Very_Close (UKM1, UKM2)))

{

Return

UK

UKM1) / 2.0;

}

RETURN (FABS (UKP1-UK) * UKM1 FABS (UKM1-UKM2) *

UK

) / (FABS (UKP1-UK) FABS (UKM1-UKM2));

}

Set , point2d_x_less_delta> PTS;

}

#ENDIF