Title stata.com solvenl() — Solve systems of nonlinear equations

Title



solvenl( ) �� Solve systems of nonlinear equations

Description

Diagnostics

Syntax

References

Remarks and examples

Also see

Conformability

Description

The solvenl() suite of functions finds solutions to systems of nonlinear equations.

solvenl init() initializes the problem and returns S, a structure that contains information regarding

the problem, including default values. If you declare a storage type for S, declare it to be a

transmorphic scalar.

The solvenl init *(S, . . .) functions allow you to modify those default values and specify other

aspects of your problem, including whether your problem refers to finding a fixed point or a zero

starting value to use, etc.

solvenl solve(S) solves the problem. solvenl solve() returns a vector that represents either

a fixed point of your function or a vector at which your function is equal to a vector of zeros.

The solvenl result *(S) functions let you access other information associated with the solution

to your problem, including whether a solution was achieved, the final Jacobian matrix, and diagnostics.

Aside: The solvenl init *(S, . . .) functions have two modes of operation. Each has an optional

argument that you specify to set the value and that you omit to query the value. For instance, the

full syntax of solvenl init startingvals() is

void solvenl_init_startingvals(S, real colvector ivals)

real colvector solvenl_init_startingvals(S)

The first syntax sets the parameter values and returns nothing. The second syntax returns the previously

set (or default, if not set) parameter values.

All the solvenl init *(S, . . .) functions work the same way.

1

2

solvenl( ) �� Solve systems of nonlinear equations

Syntax

S = solvenl init()

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)

(varies)





solvenl init type(S , { "fixedpoint" | "zero" } )





solvenl init startingvals(S , real colvector ivals )





solvenl init numeq(S , real scalar nvars )





solvenl init technique(S , "technique" )





solvenl init conv iterchng(S , real scalar itol )





solvenl init conv nearzero(S , real scalar ztol )





solvenl init conv maxiter(S , real scalar maxiter )





solvenl init evaluator(S , &evaluator() )





solvenl init argument(S, real scalar k , X )





solvenl init narguments(S , real scalar K )





solvenl init damping(S , real scalar damp )





solvenl init iter log(S , { "on" | "off" } )





solvenl init iter dot(S , { "on" | "off" } )





solvenl init iter dot indent(S , real scalar indent )





solvenl init deriv usemin(S , { "off" | "on" } )





solvenl init deriv min(S , real rowvector min )

real colvector solvenl solve(S)

real scalar

solvenl solve(S)

real scalar

solvenl result converged(S)

real scalar

solvenl result conv iter(S)

real scalar

solvenl result conv iterchng(S)

real scalar

solvenl result conv nearzero(S)

real colvector solvenl result values(S)

real matrix

solvenl result Jacobian(S)

real scalar

solvenl result error code(S)

real scalar

solvenl result return code(S)

string scalar

solvenl result error text(S)

void

solvenl dump(S)

solvenl( ) �� Solve systems of nonlinear equations

3

S, if it is declared, should be declared as

transmorphic S

and technique optionally specified in solvenl init technique() is one of the following:

technique

gaussseidel

dampedgaussseidel

broydenpowell

* newtonraphson

Description

Gauss�CSeidel

Damped Gauss�CSeidel

Broyden�CPowell

Newton�CRaphson

* newton may also be abbreviated as nr.

For fixed-point problems, allowed techniques are gaussseidel and dampedgaussseidel. For zerofinding problems, allowed techniques are broydenpowell and newtonraphson. solvenl *() exits

with an error message if you specify a technique that is incompatible with the type of evaluator

you declared by using solvenl init type(). The default technique for fixed-point problems

is dampedgaussseidel with a damping parameter of 0.1. The default technique for zero-finding

problems is broydenpowell.

Remarks and examples

Remarks are presented under the following headings:

Introduction

A fixed-point example

A zero-finding example

Writing a fixed-point problem as a zero-finding problem and vice versa

Gauss�CSeidel methods

Newton-type methods

Convergence criteria

Exiting early

Functions

solvenl init( )

solvenl init type( )

solvenl init startingvals(( )

solvenl init numeq( )

solvenl init technique( )

solvenl init conv iterchng( )

solvenl init conv nearzero( )

solvenl init conv maxiter( )

solvenl init evaluator( )

solvenl init argument( ) and solvenl init narguments()

solvenl init damping( )

solvenl init iter log( )

solvenl init iter dot( )

solvenl init iter dot indent( )

solvenl init deriv usemin( ) and solvenl init deriv min()

solvenl solve( ) and solvenl solve()

solvenl result converged( )

solvenl result conv iter( )

solvenl result conv iterchng( )

solvenl result conv nearzero( )

solvenl result values( )

solvenl result Jacobian( )

solvenl result error code( ), . . . return code(), and . . . error text()

solvenl dump( )



4

solvenl( ) �� Solve systems of nonlinear equations

Introduction

Let x denote a k �� 1 vector and let F : Rk �� Rk denote a function that represents a system of

equations. The solvenl() suite of functions can be used to find fixed-point solutions x? = F(x? ),

and it can be used to find a zero of the function, that is, a vector x? such that F(x? ) = 0.

Four solution methods are available: Gauss�CSeidel (GS), damped Gauss�CSeidel (dGS), Newton��s

method (also known as the Newton�CRaphson method), and the Broyden�CPowell (BP) method. The

first two methods are used to find fixed points, and the latter two are used to find zeros. However,

as we discuss below, fixed-point problems can be rewritten as zero-finding problems, and many

zero-finding problems can be rewritten as fixed-point problems.

Solving systems of nonlinear equations is inherently more difficult than minimizing or maximizing

a function. The set of first-order conditions associated with an optimization problem satisfies a set

of integrability conditions, while solvenl *() works with arbitrary systems of nonlinear equations.

Moreover, while one may be tempted to approach a zero-finding problem by defining a function

f (x) = F(x)0 F(x)

and minimizing f (x), there is a high probability that the minimizer will find a local minimum for

which F(x) 6= 0 (Press et al. 2007, 476). Some problems may have multiple solutions.

A fixed-point example

We want to solve the system of equations

x=

5

3

? 23 y

y=

10

3

? 23 x

First, we write a program that takes two arguments: a column vector representing the values at which

we are to evaluate our function and a column vector into which we are to place the function values.

: void function myfun(real colvector from, real colvector values)

> {

>

values[1] = 5/3 - 2/3*from[2]

>

values[2] = 10/3 - 2/3*from[1]

> }

Our invocation of solvenl *() proceeds as follows:

: S = solvenl_init()

: solvenl_init_evaluator(S, &myfun())

: solvenl_init_type(S, "fixedpoint")

: solvenl_init_technique(S, "gaussseidel")

: solvenl_init_numeq(S, 2)

: solvenl_init_iter_log(S, "on")

: x = solvenl_solve(S)

Iteration 1:

3.3333333

Iteration 2:

.83333333

(output omitted )

: x

1

1

2

-.9999999981

4

solvenl( ) �� Solve systems of nonlinear equations

5

In our equation with x on the left-hand side, x did not appear on the right-hand side, and similarly for

the equation with y. However, that is not required. Fixed-point problems with left-hand-side variables

appearing on the right-hand side of the same equation can be solved, though they typically require

more iterations to reach convergence.

A zero-finding example

We wish to solve the following system of equations (Burden, Faires, and Burden 2016, 657) for the

three unknowns x, y, and z:

10 ? x ey ? z = 0

12 ? x e2y ? 2z = 0

15 ? x e3y ? 3z = 0

We will use Newton��s method. We cannot use x = y = z = 0 as initial values because the Jacobian

matrix is singular at that point; we will instead use x = y = z = 0.2. Our program is

: void function myfun2(real colvector x, real

> {

>

values[1] = 10 - x[1]*exp(x[2]*1) >

values[2] = 12 - x[1]*exp(x[2]*2) >

values[3] = 15 - x[1]*exp(x[2]*3) > }

: S = solvenl_init()

: solvenl_init_evaluator(S, &myfun2())

: solvenl_init_type(S, "zero")

: solvenl_init_technique(S, "newton")

: solvenl_init_numeq(S, 3)

: solvenl_init_startingvals(S, J(3,1,.2))

: solvenl_init_iter_log(S, "on")

: x = solvenl_solve(S)

Iteration 0: function = 416.03613

Iteration 1: function = 63.014451 delta X =

Iteration 2: function = 56.331397 delta X =

Iteration 3: function = 48.572941 delta X =

Iteration 4: function = 37.434106 delta X =

Iteration 5: function = 19.737501 delta X =

Iteration 6: function = .49995202 delta X =

Iteration 7: function = 1.164e-08 delta X =

Iteration 8: function = 4.154e-16 delta X =

: x

1

1

2

3

colvector values)

x[3]*1

x[3]*2

x[3]*3

1.2538445

.70226488

.35269647

.30727054

.38136739

.2299557

.09321045

.00011039

8.771286448

.2596954499

-1.372281335

Writing a fixed-point problem as a zero-finding problem and vice versa

Earlier, we solved the system of equations

x=

5

3

? 23 y

y=

10

3

? 23 x

 ................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download