Partial function

A function partial application has the form of a function call with certain formal parameters bound to expressions. A function partial application returns a partially evaluated function that is also a function, with the remaining not bound formal parameters still present in the same order as in the original function declaration. A function partial application is specified by the function keyword followed by a function call to func_name giving named formal parameter associations for the formal parameters to be bound:

function func_name(..., formal_parameter_name = expr, ...)

Note that the keyword function in a function partial application differentiates the syntax from a normal function call where some parameters have been left out and instead are supplied via default values.

The function created by the function partial application acts as the original function but with the bound formal input parameters(s) removed, i.e., they cannot be supplied arguments at function call. The binding occurs when the partially evaluated function is created. A partially evaluated function is type compatible (see section 6.5) to the same function with all bound arguments removed.

The following examples show a function partial application function Sine(A=2,w=3) with the two extra arguments A and w bound and thus eliminated, i.e., the resulting function is type compatible to Integrand with only formal parameters x and y left. The first example below, QuadratureSine1, has a call with a named input argument.

function quadrature "Integrate function y=integrand(x) from x1 to x2" input Real x1; input Real x2; input Integrand integrand = Modelica.Math.sin; // With default integrand // Case without default: input Integrand integrand; output Real integral; algorithm integral :=(x2-x1)*(integrand(x1) + integrand(x2))/2; // Approximate end quadrature;
function Sine "y = Sine(A,w,x)" input Real A; input Real w; input Real x; // Note: x is currently last in the argument list. output Real y; algorithm y:=A*Modelica.Math.sin(w*x); end Sine;
partial function Integrand "Function type of Integrand functions" input Real x; output Real y; end Integrand;

Instead of repeating the declaration of input formal parameter x and output formal parameter y, they can be inherited from Integrand, which is fine despite A and w now being at the end of the parameter list:

loadModel(Modelica)
function Sine "y = Sine(x,A,w)" extends Integrand; input Real A; input Real w; algorithm y:=A*Modelica.Math.sin(w*x); end Sine;
model QuadratureSine1 "Coarse approximation with one quadrature call" Real area; equation area = quadrature(0, 1, integrand = function Sine(A=2, w=3)); end QuadratureSine1;
simulate(QuadratureSine1)
plot(area)

The second example, QuadratureSine2, shows a function partial application being passed as a positional argument. The numeric approximation of the integral will be better since a number of calls to quadrature on many short intervals are summed. The quadrature approximation that the integrated function is a straight line is typically more true over a short interval.

model QuadratureSine2 "Finer approximation, N quadrature calls" parameter Integer N; Real area; algorithm area := 0; for i in 1:N loop area := area + quadrature(0, 1, function Sine(A=2, w=i*time)); end for; end QuadratureSine2;
simulate(QuadratureSine2)
plot(area)

Below is an example of a function partial application of the function SurfaceIntegrand which is an instance called in the function surfaceQuadrature

partial function SurfaceIntegrand input Real x; input Real y; output Real z; end SurfaceIntegrand;
function quadratureOnce input Real x; input Real y1; input Real y2; input SurfaceIntegrand integrand; output Real z; algorithm z := quadrature(y1, y2, function integrand(y=x)); end quadratureOnce;
function surfaceQuadrature input Real x1; input Real x2; input Real y1; input Real y2; input SurfaceIntegrand integrand; output Real integral; algorithm integral := quadrature(x1, x2, function quadratureOnce(y1=y1, y2=y2, integrand=integrand)); end surfaceQuadrature;