Name parameters

This article or the following section is not adequately provided with supporting documents ( e.g. individual evidence ). Information without sufficient evidence could be removed soon. Please help Wikipedia by researching the information and including good evidence.

Evidence is missing. - SteEis ( Discussion  |  Rating  |  Posts ) 5:20 pm, 11th Dec. 2018 (CET)

A name parameter (English call by name ) is a parameter of a subroutine in programming languages that is not calculated when it is transferred, but only when it is used, according to the signature of the actual parameter. This was mainly used in the COBOL programming language and also in ALGOL 60 , but is unusual in modern languages.

To classify: In Fortran there are only reference parameters , in C and Java only value parameters , in C ++ there are both. With the exception of preprocessor macros in C and C ++, whose arguments are name parameters, name parameters do not exist in any of these languages.

Name parameters enable both the transfer and return of values.

A simple example

A[1] := 10
A[2] := 20
i := 1
x := Funkt (A[i], i)

FUNCTION Funkt (a, i) : Real
  i := i+1
  RETURN a
END

x is assigned the value 20. In the case of value parameters, however, x would be 10, as is the case with reference parameters.

An applied example in ALGOL 60

The Simpson approximation formula for calculating the integral is used as an example . An area integral

${\displaystyle y=f(x)}$

${\displaystyle F=\int _{a}^{b}{ydx}}$

can be divided into n strips of width h . Then the approximation used here is:

${\displaystyle h=(b-a)/n}$

${\displaystyle y_{i}=f(x_{i})\quad \quad mit\quad x_{i}=a+h\cdot i,\quad i=0\dots n}$

${\displaystyle F\approx {\frac {h}{3}}(y_{0}+y_{n}+4(y_{1}+y_{3}+\cdots y_{n-1})+2(y_{2}+y_{4}+\cdots +y_{n-2}))}$

In Algol 60 this is implemented as follows (the example is not optimal, but a precise implementation of the definition):

 1 'REAL' 'PROCEDURE' SIMPSON(A,B,F,X,N);
 2    'REAL' A, B, X;
 3    'INTEGER' N;
 4    'REAL' 'PROCEDURE' F;
 5 'BEGIN'
 6    'INTEGER' I;
 7    'REAL' H, S1, S2;
 8    'ARRAY' Y[0:N]; 
 9    H := (B-A)/N;
10    'FOR' I:=0 'STEP' 1 'UNTIL' N 'DO' 
11       'BEGIN'  
12          X:=A+H*I;
13          Y[I]:=F;
14       'END';
15    S1 := S2 := 0;
16    'FOR' I:=1 'STEP' 2 'UNTIL' N-1 'DO' S1:=S1+Y[I];
17    'FOR' I:=2 'STEP' 2 'UNTIL' N-2 'DO' S2:=S2+Y[I];
18    SIMPSON:=H/3*(Y[0]+Y[N]+4*S1+2*S2);
19 'END'

All parameters here are name parameters. Special use is made of this for parameters X and F (lines 12 and 13). A dynamic field is declared in line 8 . The integral

${\displaystyle y=\int _{0}^{1}{\sin(k)}dk}$

is calculated approximately ( n = 20 ) using

 Y:=SIMPSON(0,1,SIN(K),K,20);

In subprogram SIMPSON is here F by SIN (K) and X by K replaced.

Double integrals are also possible:

The definite integral

${\displaystyle z=\int _{0}^{1}{\int _{-1}^{1}{e^{\sqrt {x^{2}+y^{2}}}dy}\,dx}}$

can approximate with

 Z:=SIMPSON(0,1,SIMPSON(-1,1,EXP(SQRT(X 'POWER' 2+Y 'POWER' 2)),Y,20),X,20);

be calculated. This cannot be implemented in this form with reference parameters, value parameters or with simple C macros.