OneDimSolve Class Reference

#include <solution.h>

Public Member Functions
	OneDimSolve (R1_R1 &f, Real AccY=0.0001, Real AccX=0.0)
Real	Solve (Real Y, Real X, Real Dev, int Lim=100)

Private Member Functions
void	LookAt (int)
void	VFlip ()
void	HFlip ()
void	Flip ()
void	State (int I, int J, int K)
void	Linear (int, int, int)
void	Quadratic (int, int, int)

Private Attributes
R1_R1 &	function
Real	accX
Real	accY
int	lim
Real	x [3]
Real	y [3]
int	L
int	C
int	U
int	Last
int	vpol
int	hpol
Real	YY
int	i
bool	Finish
bool	Captured

Detailed Description

Definition at line 53 of file solution.h.

Constructor & Destructor Documentation

OneDimSolve()

OneDimSolve::OneDimSolve ( R1_R1 &  f, Real  AccY = 0.0001, Real  AccX = 0.0  )

inline

Definition at line 61 of file solution.h.

      : function(f), accX(AccX), accY(AccY) {}

Member Function Documentation

Flip()

void OneDimSolve::Flip ( )

private

Definition at line 65 of file solution.cpp.

References C, hpol, L, State(), U, vpol, and y.

Referenced by Solve().

{
   hpol=-hpol; vpol=-vpol; State(U,C,L);
   y[0] = -y[0]; y[1] = -y[1]; y[2] = -y[2];
}

HFlip()

void OneDimSolve::HFlip ( )

private

Definition at line 60 of file solution.cpp.

References C, hpol, L, State(), and U.

Referenced by Solve().

{ hpol=-hpol; State(U,C,L); }

Linear()

void OneDimSolve::Linear ( int  I, int  J, int  K  )

private

Definition at line 73 of file solution.cpp.

References x, and y.

Referenced by Solve().

{
   x[J] = (x[I]*y[K] - x[K]*y[I])/(y[K] - y[I]);
   // cout << "Linear\n";
}

LookAt()

void OneDimSolve::LookAt ( int  V )

private

Definition at line 49 of file solution.cpp.

References accX, accY, Captured, Finish, L, Last, lim, U, vpol, x, y, and YY.

Referenced by Solve().

{
   lim--;
   if (!lim) Throw(SolutionException("Does not converge"));
   Last = V;
   Real yy = function(x[V]) - YY;
   Finish = (std::fabs(yy) <= accY) ||
      (Captured && std::fabs(x[L]-x[U]) <= accX );
   y[V] = vpol*yy;
}

Quadratic()

void OneDimSolve::Quadratic ( int  I, int  J, int  K  )

private

Definition at line 79 of file solution.cpp.

References square(), x, and y.

Referenced by Solve().

{
   // result to overwrite I
   Real YJK, YIK, YIJ, XKI, XKJ;
   YJK = y[J] - y[K]; YIK = y[I] - y[K]; YIJ = y[I] - y[J];
   XKI = (x[K] - x[I]);
   XKJ = (x[K]*y[J] - x[J]*y[K])/YJK;
   if ( square(YJK/YIK)>(x[K] - x[J])/XKI ||
      square(YIJ/YIK)>(x[J] - x[I])/XKI )
   {
      x[I] = XKJ;
      // cout << "Quadratic - exceptional\n";
   }
   else
   {
      XKI = (x[K]*y[I] - x[I]*y[K])/YIK;
      x[I] = (XKJ*y[I] - XKI*y[J])/YIJ;
      // cout << "Quadratic - normal\n";
   }
}

Solve()

Real OneDimSolve::Solve	(	Real	Y,
		Real	X,
		Real	Dev,
		int	Lim = 100
	)

Definition at line 100 of file solution.cpp.

References C, Captured, Finish, Flip(), HFlip(), hpol, i, L, Last, lim, Linear(), LookAt(), Quadratic(), State(), U, VFlip(), vpol, x, y, and YY.

{
   enum Loop { start, captured1, captured2, binary, finish };
   Tracer et("OneDimSolve::Solve");
   lim=Lim; Captured = false;
   if (Dev==0.0) Throw(SolutionException("Dev is zero"));
   L=0; C=1; U=2; vpol=1; hpol=1; y[C]=0.0; y[U]=0.0;
   if (Dev<0.0) { hpol=-1; Dev = -Dev; }
   YY=Y;                                // target value
   x[L] = X;                            // initial trial value
   if (!function.IsValid(X))
      Throw(SolutionException("Starting value is invalid"));
   Loop TheLoop = start;
   for (;;)
   {
      switch (TheLoop)
      {
      case start:
         LookAt(L); if (Finish) { TheLoop = finish; break; }
         if (y[L]>0.0) VFlip();               // so Y[L] < 0

         x[U] = X + Dev * hpol;
         if (!function.maxXinf && x[U] > function.maxX)
            x[U] = (function.maxX + X) / 2.0;
         if (!function.minXinf && x[U] < function.minX)
            x[U] = (function.minX + X) / 2.0;

         LookAt(U); if (Finish) { TheLoop = finish; break; }
         if (y[U] > 0.0) { TheLoop = captured1; Captured = true; break; }
         if (y[U] == y[L])
            Throw(SolutionException("Function is flat"));
         if (y[U] < y[L]) HFlip();             // Change direction
         State(L,U,C);
         for (i=0; i<20; i++)
         {
            // cout << "Searching for crossing point\n";
            // Have L C then crossing point, Y[L]<Y[C]<0
            x[U] = x[C] + Dev * hpol;
            if (!function.maxXinf && x[U] > function.maxX)
            x[U] = (function.maxX + x[C]) / 2.0;
            if (!function.minXinf && x[U] < function.minX)
            x[U] = (function.minX + x[C]) / 2.0;

            LookAt(U); if (Finish) { TheLoop = finish; break; }
            if (y[U] > 0) { TheLoop = captured2; Captured = true; break; }
            if (y[U] < y[C])
                Throw(SolutionException("Function is not monotone"));
            Dev *= 2.0;
            State(C,U,L);
         }
         if (TheLoop != start ) break;
         Throw(SolutionException("Cannot locate a crossing point"));

      case captured1:
         // cout << "Captured - 1\n";
         // We have 2 points L and U with crossing between them
         Linear(L,C,U);                   // linear interpolation
                                          // - result to C
         LookAt(C); if (Finish) { TheLoop = finish; break; }
         if (y[C] > 0.0) Flip();            // Want y[C] < 0
         if (y[C] < 0.5*y[L]) { State(C,L,U); TheLoop = binary; break; }

      case captured2:
         // cout << "Captured - 2\n";
         // We have L,C before crossing, U after crossing
         Quadratic(L,C,U);                // quad interpolation
                                          // - result to L
         State(C,L,U);
         if ((x[C] - x[L])*hpol <= 0.0 || (x[C] - x[U])*hpol >= 0.0)
            { TheLoop = captured1; break; }
         LookAt(C); if (Finish) { TheLoop = finish; break; }
         // cout << "Through first stage\n";
         if (y[C] > 0.0) Flip();
         if (y[C] > 0.5*y[L]) { TheLoop = captured2; break; }
         else { State(C,L,U); TheLoop = captured1; break; }

      case binary:
         // We have L, U around crossing - do binary search
         // cout << "Binary\n";
         for (i=3; i; i--)
         {
            x[C] = 0.5*(x[L]+x[U]);
            LookAt(C); if (Finish) { TheLoop = finish; break; }
            if (y[C]>0.0) State(L,U,C); else State(C,L,U);
         }
         if (TheLoop != binary) break;
         TheLoop = captured1; break;

      case finish:
     return x[Last];

      }
   }
}

State()

void OneDimSolve::State ( int  I, int  J, int  K  )

private

Definition at line 71 of file solution.cpp.

References C, L, and U.

Referenced by Flip(), HFlip(), and Solve().

{ L=I; C=J; U=K; }

VFlip()

void OneDimSolve::VFlip ( )

private

Definition at line 62 of file solution.cpp.

References vpol, and y.

Referenced by Solve().

   { vpol = -vpol; y[0] = -y[0]; y[1] = -y[1]; y[2] = -y[2]; }

Member Data Documentation

accX

Real OneDimSolve::accX

private

Definition at line 56 of file solution.h.

Referenced by LookAt().

accY

Real OneDimSolve::accY

private

Definition at line 57 of file solution.h.

Referenced by LookAt().

C

int OneDimSolve::C

private

Definition at line 73 of file solution.h.

Referenced by Flip(), HFlip(), Solve(), and State().

Captured

bool OneDimSolve::Captured

private

Definition at line 79 of file solution.h.

Referenced by LookAt(), and Solve().

Finish

bool OneDimSolve::Finish

private

Definition at line 78 of file solution.h.

Referenced by LookAt(), and Solve().

function

R1_R1& OneDimSolve::function

private

Definition at line 55 of file solution.h.

hpol

int OneDimSolve::hpol

private

Definition at line 74 of file solution.h.

Referenced by Flip(), HFlip(), and Solve().

i

int OneDimSolve::i

private

Definition at line 76 of file solution.h.

Referenced by Solve().

L

int OneDimSolve::L

private

Definition at line 73 of file solution.h.

Referenced by Flip(), HFlip(), LookAt(), Solve(), and State().

Last

int OneDimSolve::Last

private

Definition at line 73 of file solution.h.

Referenced by LookAt(), and Solve().

lim

int OneDimSolve::lim

private

Definition at line 58 of file solution.h.

Referenced by LookAt(), and Solve().

U

int OneDimSolve::U

private

Definition at line 73 of file solution.h.

Referenced by Flip(), HFlip(), LookAt(), Solve(), and State().

vpol

int OneDimSolve::vpol

private

Definition at line 74 of file solution.h.

Referenced by Flip(), LookAt(), Solve(), and VFlip().

x

Real OneDimSolve::x[3]

private

Definition at line 72 of file solution.h.

Referenced by Linear(), LookAt(), Quadratic(), and Solve().

y

Real OneDimSolve::y[3]

private

Definition at line 72 of file solution.h.

Referenced by Flip(), Linear(), LookAt(), Quadratic(), Solve(), and VFlip().

YY

Real OneDimSolve::YY

private

Definition at line 75 of file solution.h.

Referenced by LookAt(), and Solve().

---

The documentation for this class was generated from the following files:

• solution.h
• solution.cpp