Thank you all for the comments and suggestions.
Just to explain my thinking. The functions I am concerned with calculate a number of values for a scenario, lets call them A1,A2,A3, all declared as var parameters, and used to return values from the function (not supply values to the function).So something like
procedure SubCalc(X,Y,Z:double;var A1,A2,A3:double);
SubCalc may be called by several other functions, not all of them needing A1,A2,A3. One caller function may, for example, only need the A2 value, but still has to declare and supply variables for A1 and A2, introducing extraneous clutter in the calling function.
I could do this just by making A1,A2,A3 pointers, and have the function check for nil before putting a value in the "variable". In fact I may do this. The calling function can then use nil for values not of interest.
I don't want to use overloaded version of SubCalc, because SubCalc is often a tricky mathematically complex thing, and overloaded functions mean duplicating the code - and that seems a possible source of bugs when the function later gets modified. I could use overloaded wrapper functions around SubCalc, so just one copy of the central code, but that's not very elegant. The number of overloaded or wrapper functions could be a bit large, making for ugly, error-prone code.
To be honest, I am a little wary of overloaded functions, makes me nervous to have different functions with the same name - but that is just my personal preference. I'm happy for system supplied functions, like IntToStr, to be multiple overloaded functuions, but I don't like writing them myself.
Another possibility I considered was to have all the return values is a simple record.
It's not a huge deal, just having come across the idea on the web seemd like a neat way of reducing code complexity. The reduction in cide complecity would be fairly minor, so it's not worth too much agonising.
On a historical note. many years ago I wrote some serious scientific applications in the PL/I language from IBM. These days we are used to strict data-type checking, which I think is great coding-time bug preventer. PL/I had the opposte view, if you tried to assign, say, a string to an integer variable, then PL/I would helfully insert a call to a conversion routine (which would usually fail at run time if the string did not contain an integer because you coded a bug). So you'd have to check the compiler report which listed where conversion routines had been inserted, then go and fix the code. On the other hand PL/I did have an interesting version of overloaded function. A procedure could have multiple "entry points" of procedure headers, each with a different list of parameters. This worked quite neatly, as only one copy of the core code was needed.
One little thing I wish Pascal had copied from PL/I is that in PL/I you could write
"If A=B then Return(X)'"
which was equivalent to the Pascal
" If A=B then begin Result:=X; Exit; end".
The Pascal version just looks verbose compared to the PL/I.