/[ascend]/trunk/base/generic/compiler/extfunc.h
ViewVC logotype

Contents of /trunk/base/generic/compiler/extfunc.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 914 - (show annotations) (download) (as text)
Sat Oct 28 05:27:58 2006 UTC (13 years, 9 months ago) by johnpye
File MIME type: text/x-chdr
File size: 21622 byte(s)
Fixed prototype for extpy_destroy
Dubious fix for the message about directory node in doc/SConscript (is $ expansion happening?)

1 /*
2 ASCEND modelling environment
3 Copyright (C) 1990, 1993, 1994 Thomas Guthrie Epperly, Kirk Andre Abbott
4 Copyright (C) 2006 Benjamin Allan
5 Copyright (C) 2006 Carnegie Mellon University
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
21 *//**
22 @file
23 External Functions Module.
24
25 This module implements the ExternalFunc structure referenced by
26 black and glass box structures and external methods.
27 The ExternalFunc structure stores the number of input and
28 output parameters (formal)
29 as well as 'help' string and 'name' string' for each of these 'calls'.
30
31 This header also provides functions for ExternalFunc library maintenance.
32 This allows ASCEND to maintain a list of the ExternalFunc requests derived
33 from statements in the model(s). When compilation completes, I suppose
34 it should be possible to alert the user about any external functions
35 that were not able to be resolved.
36
37 @todo Complete documentation of compiler/extfunc.h.
38
39 Requires:
40 #include "utilities/ascConfig.h"
41 #include "compiler/instance_enum.h"
42 #include "general/list.h"
43 #include "compiler/compiler.h"
44 *//*
45 by Kirk Andre Abbott and Ben Allan
46 Created: July 4, 1994.
47 Version: $Revision: 1.5 $
48 Version control file: $RCSfile: extfunc.h,v $
49 Date last modified: $Date: 1997/07/18 12:29:30 $
50 Last modified by: $Author: mthomas $
51 */
52
53 #ifndef ASC_EXTFUNC_H
54 #define ASC_EXTFUNC_H
55
56 #include <utilities/ascConfig.h>
57 #include "relation_util.h"
58
59 /*------------------------------------------------------------------------------
60 type definitions and forward decls
61 */
62
63 /**
64 ExtEvalFunc type is a function pointer.
65
66 @see rootfind.c:51
67
68 @param mode 'to pass to the eval function' (?)
69 @param m relation index
70 @param n variable index
71 @param x 'x' vector (?)
72 @param u 'u' vector (?)
73 @param f vector of residuals
74 @param g vector of gradients
75 */
76 typedef int ExtEvalFunc(int *mode, int *m, int *n,
77 double *x, double *u, double *f, double *g);
78
79 /**
80 This is an enum to clarify and make type-safer the
81 the variation of external functions circa 1995.
82 Blackboxes might be callable from methods as well (@TODO), but
83 this is dependent on their code registration to setup.
84 */
85 enum ExternalFuncType {
86 efunc_ERR = 0, /**< err value (Traps old mode errors too) */
87 efunc_BlackBox = 10, /**< remainder of struct is blackbox */
88 efunc_GlassBox = 20, /**< remainder of struct is glassbox */
89 efunc_Method = 30 /**< remainder of struct is method */
90 };
91
92 struct GlassBoxExternalFunc {
93 ExtEvalFunc *initial;
94 ExtEvalFunc **value; /**< array of relation residual functions. */
95 ExtEvalFunc **deriv; /**< array of relation gradient functions. */
96 ExtEvalFunc **deriv2; /**< array of relation hessian functions. */
97 ExtEvalFunc *final; /**< cleanup function. */
98 };
99
100
101 /** values a blackbox (or ?) can report when returning. */
102 enum Calc_status {
103 calc_converged,
104 calc_diverged,
105 calc_fp_error,
106 calc_incorrect_args,
107 calc_error,
108 calc_all_ok
109 };
110
111 /**
112 Things that a blackbox can be asked to do.
113
114 @NOTE Rhetorical question: Why do we want this? See comments in Slv_Interp.
115 */
116 enum Request_type {
117 bb_none, /**< do nothing. should never be sent. */
118 bb_first_call, /**< will be given when the initial function pointer is called. */
119 bb_last_call, /**< will be given when the final function pointer is called. */
120 bb_check_args, /**< do any argument checking of the variables, data */
121 bb_recalculate, /**< the caller thinks the input may have changed: recalc if reqd */
122 bb_func_eval, /**< the caller needs the residual function pointer. */
123 bb_deriv_eval, /**< the caller needs the deriv function pointer. */
124 bb_hess_eval, /**< the caller needs the hessian function pointer. */
125 bb_single_step /**< the caller would like one step toward the solution;
126 usually this is meaningless and should be answered with calc_diverged. */
127 };
128
129 /**
130 Each blackbox equation may show up more than once in a simulation
131 if models repeat in the structure. For each occurence of the
132 blackbox, a unique BBoxInterp object is given when the set of
133 corresponding relations is created.
134 It is used for the blackbox to communicate to the rest of the system.
135 If the blackbox retains internal state between evaluation calls,
136 it should store this state in the user_data pointer.
137 */
138 struct BBoxInterp {
139 /** status is set by blackbox calls before returning. */
140 enum Calc_status status;
141
142 /** user_data is set by the blackbox if it has any persistent state
143 during calls to initial and final functions given in
144 CreateUserFunctionBlackBox.
145 */
146 void *user_data;
147
148 /** What the caller wants done on a given call.
149
150 As black boxes are represented with 5 function pointers,
151 one might think this is not needed. Providing the 'task' here allows
152 one to implement only one function and have it handle all types of
153 calls. It also facilitates cases where there is checking rather than
154 evaluation.
155
156 @NOTE Problem? Don't init functions and evaluation functions have
157 different signatures?
158 */
159 enum Request_type task;
160 /* if someone still needs a nodestamp, we could go back to
161 defining one, but it should really be inside user_data as
162 ascend doesn't need it. */
163
164 };
165
166 typedef int ExtBBoxInitFunc(struct BBoxInterp *interp,
167 struct Instance *data,
168 struct gl_list_t *arglist);
169 /**<
170 Note Well: References to ascend instances must not be
171 cached in the user_data of interp, as instances may move
172 in the dynamically typed ASCEND world.
173 @param interp is the structure that all subsequent calls to
174 evaluation functions will include.
175 @param data is the DATA instance from the ascend model.
176 @param arglist is the input and output list of instance lists,
177 where each element corresponds to a formal argument.
178 Elements 1:n_formal_inputs are the inputs and the next
179 n_formal_outputs elements are the outputs.
180 @return 0 if ok, nonzero if some error makes the blackbox impossible.
181
182 */
183
184 typedef void ExtBBoxFinalFunc(struct BBoxInterp *interp);
185 /**< @param interp same as called in init and evaluate.
186 This is the opportunity to deallocate user_data as the
187 instance is being destroyed.
188 */
189
190 /**
191 External black box equations are of the block form
192 y_out = f(x_in). This block expands to N_outputs equations
193 of the form y_out[i] = f_i(x_in), where the functional details
194 of f are assumed to be smooth enough but otherwise totally hidden
195 and x_in, y_out are non-overlapping sets of variables.
196 The compiler will warn if overlap is detected.
197 Normal D.O.F. solver analysis applies in most cases.
198
199 Note that solvers are not psychic; if this blackbox is embedded
200 in a larger model such that some of y_out are inconsistently
201 fixed variables, the odds of convergence are small.
202 Cleverer solvers may issue a warning.
203
204 @param interp the control information is exchanged in interp;
205 interp->task should be consulted.
206 @param ninputs the length of the inputs, xi_in.
207 @param noutputs, the length of the outputs, y_out.
208
209 @param jacobian, the partial derivative df/dx, where
210 each row is df[i]/dx[j] over each j for the y_out[i] of
211 matching index. The jacobian array is 1-D, row major, i.e.
212 df[i]/dx[j] -> jacobian[i*ninputs+j].
213
214 @TODO this one may need splitting/rework for hessian.
215 */
216 typedef int ExtBBoxFunc(struct BBoxInterp *interp,
217 int ninputs, int noutputs,
218 double *inputs, double *outputs, double *jacobian);
219
220 struct BlackBoxExternalFunc {
221 ExtBBoxInitFunc *initial; /**< called after instance construction */
222 ExtBBoxFunc *value; /**< relation residual function. */
223 ExtBBoxFunc *deriv; /**< relation gradient function (see jacobian)*/
224 ExtBBoxFunc *deriv2; /**< relation hessian function. */
225 ExtBBoxFinalFunc *final; /**< cleanup function called at instance destruction. */
226 double inputTolerance; /**< largest change in an input variable
227 that is allowable without recalculating. */
228 };
229
230
231 /**
232 Function pointer (type) to implement an external method on a particular
233 instance
234
235 @param context the instance on which the method is run.
236 context may also appear explicitly in the arg list as SELF.
237 @param args Each element of args is a list of instances; each
238 name in the ascend-language argument list is expanded to a list
239 (which may contain 0 or more Instances) and appended to args.
240 @return ???
241 */
242 typedef int ExtMethodRun(struct Instance *context, struct gl_list_t *args, void *user_data);
243
244 /**
245 Setup/teardown, if any needed, for a particular instance.
246
247 We don't actually support this method anywhere right now, as
248 we're not sure what it can logically be used for that the
249 init function in dlopening shouldn't be doing.
250 In principal, we could add and cache a client-data pointer
251 in each instance so that the external method may be stateful.
252 Presently, the external methods must be clever to do that
253 on their own or must use ascend instances for state instead.
254 @param context the instance on which the method may be run.
255 */
256 typedef int ExtMethodInit( struct Instance *context);
257
258 /**
259 Destroy function (note comments for ExtMethodInit).
260
261 This function deallocated user_data for a particular external method.
262 In the case of external python script methods, for example, this will perform
263 Py_DECREF on the external script, so that python can unload it.
264
265 Couldn't see a way to do this without adding back this function here. -- JP
266
267 @return 0 on success, else error code.
268 */
269
270 typedef int ExtMethodDestroyFn( void *user_data);
271
272
273 struct MethodExternalFunc {
274 ExtMethodRun *run; /**< the method invoked. */
275 void *user_data; /**< I'd anticipate that this would be a function pointer
276 implemented in an external scripting language. Should only be accessed
277 from inside the 'run' function! -- JP */
278 ExtMethodDestroyFn *destroyfn;
279 };
280
281 struct ExternalFunc {
282 enum ExternalFuncType etype;
283 CONST char *name; /**< a string we own. */
284 CONST char *help; /**< a string we own. */
285 unsigned long n_inputs; /**< expected # of formal inputs. */
286 unsigned long n_outputs; /**< expected # of formal outputs. */
287 union {
288 struct GlassBoxExternalFunc glass;
289 struct BlackBoxExternalFunc black;
290 struct MethodExternalFunc method;
291 } u;
292 };
293
294 /*------------------------------------------------------------------------------
295 REGISTRATION / LOOKUP FUNCTIONS
296 */
297
298
299 extern void InitExternalFuncLibrary(void);
300 /**<
301 The main external functions library initialization routine. This
302 function must be called before all others.
303 */
304
305 extern void DestroyExtFuncLibrary(void);
306 /**<
307 Destroys the external function library and deallocates all the
308 information associated with it.
309 */
310
311
312 extern int AddExternalFunc(struct ExternalFunc *efunc, int force);
313 /**<
314 Adds an external function node to the external function library.
315 We look up the external function before adding it to the
316 library. If force is zero and the function exists then nothing
317 is done and 0 is returned. If force is true, then the old entry is
318 removed and the new one is added; 1 is returned. If the name is not
319 found then the information is added to the library.
320
321 @return 1 if an element is added to ExternalFunctionLibrary Table,
322 or 0 if no addition is made.
323 */
324
325 ASC_DLLSPEC(struct ExternalFunc *) LookupExtFunc(CONST char *funcname);
326 /**<
327 Returns the external function having the given name, or NULL if
328 not found.
329 */
330
331
332 extern struct ExternalFunc *RemoveExternalFunc(char *name);
333 /**<
334 Removes the external function having the given name from the
335 External function library.
336 */
337
338 extern void DestroyExternalFunc(struct ExternalFunc *name);
339 /**<
340 Destroys an external function, but does *not* remove it from the
341 library. Use the RemoveExternalFunc library first to retrieve the
342 information, then call this function.
343 */
344
345
346 extern void PrintExtFuncLibrary(FILE *f);
347 /**<
348 Prints the contents of the external function library to the given
349 file. The file must be opened for writing.
350 */
351
352 ASC_DLLSPEC(char *) WriteExtFuncLibraryString(void);
353 /**<
354 Returns a string of formatted information about the external functions
355 defined. the string looks like "{{name1} {help1}} {{name2} {help2}} "
356 The string may be empty/NULL if there are no external functions loaded.
357 */
358
359 /**
360 This provides a way for other code to visit the external function list
361 */
362 ASC_DLLSPEC(void) TraverseExtFuncLibrary(void (*)(void *,void *),void *secondparam);
363
364
365 /** fetch the required formal input count for glass, black, or method. */
366 ASC_DLLSPEC(unsigned long) NumberInputArgs(CONST struct ExternalFunc *efunc);
367
368 /** fetch the required formal output count for glass, black, or method. */
369 ASC_DLLSPEC(unsigned long) NumberOutputArgs(CONST struct ExternalFunc *efunc);
370
371
372 ASC_DLLSPEC(CONST char*) ExternalFuncName(CONST struct ExternalFunc *efunc);
373 /**<
374 Returns the name of an external function.
375 */
376
377 /*------------------------------------------------------------------------------
378 EXTERNAL METHOD STUFF
379 */
380
381 ASC_DLLSPEC(int) CreateUserFunctionMethod(CONST char *name
382 ,ExtMethodRun *run
383 ,CONST long n_args
384 ,CONST char *help
385 ,void *user_data
386 ,ExtMethodDestroyFn *destroyfn
387 );
388 /**<
389 * Adds an external method call to the ASCEND system.
390 * The name of the function is looked up. If it already exists, the
391 * information will be updated. If the name was not found in the
392 * external function library, then an external function node will be
393 * created and added to the external function library. We make a
394 * *copy* of the help string if it is provided. We also make a copy
395 * of the name. Anyone desirous of ASCEND knowing about their
396 * external methods must use this protocol.
397 *
398 *
399 * Note on blackbox integration with nonlinear solvers:
400 * The basic idea is that the blackbox has inputs x and outputs y
401 * that are all variables to the ascend model. Some of these may
402 * be fixed variables, but this is of no consequence to the blackbox
403 * routine unless one of the fixed variables is fixed outside the
404 * bounds of feasible input to the box. In the newton solution
405 * process there are three sets of values involved, x (inputs),
406 * yhat (the outputs as computed by the box), and y (the proposed
407 * values of the outputs in the model which may not match yhat
408 * until the entire model is converged. The many equations of the
409 * blackbox are hidden and represented by the reduced set of
410 * equations. In mathematical form, an array of equations:
411 * y = yhat(x); (ascend form bbrel: bboxname(inputs, outputs, data);)
412 * where yhat(x) is computed as bboxname(x,yhat).
413 * The bbox may produce the reduced gradient or be finite differenced
414 * to get dyhat/dx partial derivatives.
415 * The residual then, obviously, is yhat - y and the gradient is
416 * (in matrix form) I-dyhat/dx for the reduced equations.
417 *
418 * @param name Name of the function being added (or updated).
419 * @param initial Pointer to initialisation function, or NULL if none.
420 * @param run Pointer to the method.
421 * @param final Pointer to cleanup function, or NULL if none.
422 * @param n_args number of arguments expected as input, or -1 if any number is allowed.
423 * @return Returns 0 if the function was successfully added,
424 * non-zero otherwise.
425 */
426
427 /** Fetch method run function. */
428 extern ExtMethodRun *GetExtMethodRun(struct ExternalFunc *efunc);
429 extern void *GetExtMethodUserData(struct ExternalFunc *efunc);
430
431 /*------------------------------------------------------------------------------
432 BLACK BOX STUFF
433 */
434
435 /** Fetch black initialization function. */
436 extern ExtBBoxInitFunc *GetInitFunc(struct ExternalFunc *efunc);
437 /** Fetch black residual function. */
438 extern ExtBBoxFunc *GetValueFunc(struct ExternalFunc *efunc);
439 /** Fetch black sensitivity gradient function. */
440 extern ExtBBoxFunc *GetDerivFunc(struct ExternalFunc *efunc);
441 /** Fetch black hessian function. */
442 extern ExtBBoxFunc *GetDeriv2Func(struct ExternalFunc *efunc);
443 /** Fetch black cleanup function. */
444 extern ExtBBoxFinalFunc *GetFinalFunc(struct ExternalFunc *efunc);
445 /** Fetch black inputTolerance. */
446 extern double GetValueFuncTolerance(struct ExternalFunc *efunc);
447
448
449 ASC_DLLSPEC(int) CreateUserFunctionBlackBox(CONST char *name,
450 ExtBBoxInitFunc *init,
451 ExtBBoxFunc *value,
452 ExtBBoxFunc *deriv,
453 ExtBBoxFunc *deriv2,
454 ExtBBoxFinalFunc *final,
455 CONST unsigned long n_inputs,
456 CONST unsigned long n_outputs,
457 CONST char *help,
458 double inputTolerance
459 );
460 /**<
461 Adds an external function to the ASCEND system.
462 The name of the function is looked up. If it already exists, the
463 information will be updated. If the name was not found in the
464 external function library, then an external function node will be
465 created and added to the external function library. We make a
466 *copy* of the help string if it is provided. We also make a copy
467 of the name. Anyone desirous of ASCEND knowing about their
468 functions must use this protocol.
469
470 Note on blackbox integration with nonlinear solvers:
471 The basic idea is that the blackbox has inputs x and outputs y
472 that are all variables to the ascend model. Some of these may
473 be fixed variables, but this is of no consequence to the blackbox
474 routine unless one of the fixed variables is fixed outside the
475 bounds of feasible input to the box. In the newton solution
476 process there are three sets of values involved, x (inputs),
477 yhat (the outputs as computed by the box), and y (the proposed
478 values of the outputs in the model which may not match yhat
479 until the entire model is converged. The many equations of the
480 blackbox are hidden and represented by the reduced set of
481 equations. In mathematical form, an array of equations:
482 y = yhat(x); (ascend form bbrel: bboxname(inputs, outputs, data);)
483 where yhat(x) is computed as bboxname(x,yhat).
484 The bbox may produce the reduced gradient or be finite differenced
485 to get dyhat/dx partial derivatives.
486 The residual then, obviously, is yhat - y and the gradient is
487 (in matrix form) I-dyhat/dx for the reduced equations.
488
489 @param name Name of the function being added (or updated).
490 @param init Pointer to initialisation function, or NULL if none.
491 @param final Pointer to shutdown function. May be same as init.
492 @param value evaluation function pointers, or NULL if none.
493 @param deriv first partial derivative functions, or NULL if none.
494 @param deriv2 second derivative functions, or NULL if none.
495 @param inputTolerance maximum change in any of the inputs that is
496 allowable without recomputing the outputs.
497 0.0 is conservative, or specify a larger number if the
498 outputs are only mildly sensitive to small changes in inputs.
499 @return Returns 0 if the function was successfully added,
500 non-zero otherwise.
501 */
502
503
504 ASC_DLLSPEC(int) DefaultExtBBoxFuncDerivFD(
505 struct BBoxInterp *interp,
506 int ninputs,
507 int noutputs,
508 double *inputs,
509 double *outputs,
510 double *jacobian
511 );
512 /**< Default finite-differencing code for blackboxes.
513 If the user does not supply a derivative function they wrote,
514 they must supply this derivative function instead.
515 */
516
517 /*-----------------------------------------------------------------------------
518 GLASS BOX STUFF
519 */
520
521 ASC_DLLSPEC(int) CreateUserFunctionGlassBox(CONST char *name,
522 ExtEvalFunc *init,
523 ExtEvalFunc **value,
524 ExtEvalFunc **deriv,
525 ExtEvalFunc **deriv2,
526 ExtEvalFunc *final,
527 CONST unsigned long n_inputs, CONST unsigned long n_outputs,
528 CONST char *help
529 );
530 /**<
531 Adds an external function to the ASCEND system.
532 The name of the function is looked up. If it already exists, the
533 information will be updated. If the name was not found in the
534 external function library, then an external function node will be
535 created and added to the external function library. We make a
536 *copy* of the help string if it is provided. We also make a copy
537 of the name. Anyone desirous of ASCEND knowing about their
538 functions must use this protocol.
539
540 @param name Name of the function being added (or updated).
541 @param init Pointer to initialisation function, or NULL if none.
542 @param value array of evaluation function pointers,
543 or NULL if none.
544 @param deriv array of first partial
545 derivative functions, or NULL if none.
546 @param deriv2 array of second derivative
547 functions, or NULL if none.
548 @return Returns 0 if the function was successfully added,
549 non-zero otherwise.
550 */
551
552 /** Fetch glass initialization function. */
553 extern ExtEvalFunc *GetGlassBoxInit(struct ExternalFunc *efunc);
554 /** Get glass box residual function array. */
555 extern ExtEvalFunc **GetValueJumpTable(struct ExternalFunc *efunc);
556 /** Get glass box gradient function array. */
557 extern ExtEvalFunc **GetDerivJumpTable(struct ExternalFunc *efunc);
558 /** Get glass box hessian function array. */
559 extern ExtEvalFunc **GetDeriv2JumpTable(struct ExternalFunc *efunc);
560 /** Fetch black initialization function. */
561 extern ExtEvalFunc *GetGlassBoxFinal(struct ExternalFunc *efunc);
562
563 #endif /* ASC_EXTFUNC_H */

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22