NewtonDegenerate Class Reference

#include <NewtonDegenerate.h>

Inheritance diagram for NewtonDegenerate:

[legend]Collaboration diagram for NewtonDegenerate:

[legend]List of all members.

---

Detailed Description

NewtonDegenerate is a class for finding critical points of an Implicit.

The class basically redefines the NewtonInput to set the system of equations such that grad(x) == 0 and hess(x)->determinate() == 0.

Definition at line 21 of file NewtonDegenerate.h.

Public Member Functions
	NewtonDegenerate ()
	Default constructor.
	NewtonDegenerate (Implicit *)
	Constructs an object which finds critical points for an Implicit.
virtual void	setSurface (Implicit *surf)
	Changes the surface to search.
virtual Implicit *	getSurface ()
	Returns the current surface being searched.
Protected Member Functions
virtual bool	NewtonEquation (Box< double > &X, IMatrix &A, Box< double > &b)
	Overridden NewtonEquation to solve A(Y-Xc) = b for critical points.
virtual bool	NewtonSubdivisionBreak (Box< double > &X)
	Overridden Newton solver method to stop subdividing.
Protected Attributes
Implicit *	surface
	Find critical points for this Implicit surface.

---

Constructor & Destructor Documentation

NewtonDegenerate::NewtonDegenerate (   )

Default constructor. This method isn't very useful since it sets the surface to be NULL which means that there is no surface for which to find critical points. Definition at line 20 of file NewtonDegenerate.cpp. References setSurface().

NewtonDegenerate::NewtonDegenerate (  Implicit *  surf  )

Constructs an object which finds critical points for an Implicit. You MUST pass in an Implicit surface or Newton's method won't do anything. Parameters: surf  The implicit surface to be used when finding critical points. Definition at line 30 of file NewtonDegenerate.cpp. References setSurface(), and surf.

---

Member Function Documentation

Implicit * NewtonDegenerate::getSurface (   )  [virtual]

Returns the current surface being searched. This method is virtual and should be overridden (along with setSurface(Implicit*)) to keep the surface variable consistent. Returns: The Implicit surface being searched for critical points. See also: setSurface(Implicit*) Reimplemented in SearchDegenerate. Definition at line 55 of file NewtonDegenerate.cpp. References surface. Referenced by NewtonEquation(), and NewtonSubdivisionBreak().

bool NewtonDegenerate::NewtonEquation (  Box< double > &  X, IMatrix &  A, Box< double > &  b )  [protected, virtual]

Overridden NewtonEquation to solve A(Y-Xc) = b for critical points. In the basic finding of degenerate critical points, we look for points in the Box where the function value is zero AND the gradient is zero over a 4D space (x,y,z,t). Since we are now dealing with a "time" element of the Box vector, we need to slightly alter our concept of A and b in the equation Ax + y = b. As stated in the 1978 article "Interval Forms of Newtons (sic) Method" by Eldon Hansen in "Computing" Volume 20, pp 153-163, we are now actually trying to solve two equations with two unknowns. We want to find proc(x,t)=0 and grad(X,t)=0. So we have the following: Our "function" is now a combination of two functions. When searching for critial points, our "function" was grad(), ie. we were looking for X where grad(X) = 0. Now our function is a "vector" of two functions: * Let p = proc(X,t) * * / dp \ * | -- | * | dx | * | | * | grad(X,t) | | dp | * New "function" = | proc(X,t) | = | -- | * | dy | * | | * | dp | * | -- | * | dy | * | | * \ p / * * * / dp dp dp dp \ * | ---- ---- ---- ---- | * | dx^2 dxdy dxdz dxdt | * | | * / dgrad(X,t) dgrad(X,t) \ | dp dp dp dp | * | ---------- ---------- | | ---- ---- ---- ---- | * | dX dt | | dydx dy^2 dydz dydt | * New "Jacobian" = | | = | | * | dproc(X,t) dproc(X,t) | | dp dp dp dp | * | ---------- ---------- | | ---- ---- ---- ---- | * \ dX dt / | dzdx dzdy dz^2 dzdt | * | | * | dp dp dp dp | * | ---- ---- ---- ---- | * \ dx dy dz dt / * The upper 3x3 matrix in the 4x4 Jacobian above is simply the Hessian, and the first three elements of the bottom row is simply the grad(). The last column is the tricky part. Let's start with dp/dt. When calculating proc(X,t), we use a LRP to linearly interpolate between a set of "old" Qs and "current" Qs. Eg. Using a simple function like proc=ax, we would have Intervald A = t*(a_current - a_old) + a_old, and thus proc(X,t) = AX = [t*(a_current - a_old) + a_old] * X. Taking the partial derivative of this wrt t is very simple since everything but the (a_current - a_old) term is a constant. So we get dproc(X,t)/dt = (a_current - a_old) * X. A similar calculation can be made for dgrad(X,t)/dt. Practically speaking, we can use procq and gradq (since these two functions don't really care if q is a function of t or not) along with dqdt to calculate dproc/dt and dgrad/dt, using the chain rule. Reimplemented from Newton. Definition at line 130 of file NewtonDegenerate.cpp. References IMatrix::center(), convert(), getSurface(), Implicit::grad(), Implicit::gradt(), Implicit::hess(), GaussJordan::Invert(), Implicit::proc(), Implicit::proct(), surf, and X.

bool NewtonDegenerate::NewtonSubdivisionBreak (  Box< double > &  X  )  [protected, virtual]

Overridden Newton solver method to stop subdividing. If the proc and grad of the Box being searched does not contain 0, then there aren't any degenerate roots to be found in it and we can quit looking in this Box. Parameters: X  The Box region to check for a 0 gradient. Returns: False if the gradient of the region contains a 0 value, indicating that we should check the region for a critical point. True if we CAN quit early since the region doesn't contain a 0 gradient point. Reimplemented from Newton. Definition at line 187 of file NewtonDegenerate.cpp. References getSurface(), Implicit::grad(), Intervald, Interval< Type >::isNegative(), Interval< Type >::isPositive(), Implicit::proc(), surf, and X.

void NewtonDegenerate::setSurface (  Implicit *  surf  )  [virtual]

Changes the surface to search. This method is called by the constructors to set up the private surface variable. It is also virtual and should be overridden (along with getSurface()) to keep the surface variable consistent. Parameters: surf  The new Implicit surface to search for critical points. See also: getSurface() Reimplemented in SearchDegenerate. Definition at line 43 of file NewtonDegenerate.cpp. References surf, and surface. Referenced by NewtonDegenerate().

---

Member Data Documentation

Implicit* NewtonDegenerate::surface [protected]

Find critical points for this Implicit surface. Reimplemented in SearchDegenerate. Definition at line 24 of file NewtonDegenerate.h. Referenced by getSurface(), and setSurface().

---

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

• NewtonDegenerate.h
• NewtonDegenerate.cpp

---