Function definition: Difference between revisions
Content deleted Content added
m →ES6-* |
|||
(64 intermediate revisions by 36 users not shown) | |||
Line 17:
=={{header|11l}}==
Function definition:
<
R a * b</
Lambda function definition:
<
=={{header|360 Assembly}}==
Linkage conventions are: register 1 : the parameter list, register 0 : the return value,
and register 14 : the return address.
<
USING DEFFUN,R13
SAVEAREA B PROLOG-SAVEAREA(R15)
Line 62:
Z DS F
YREGS
END DEFFUN</
=={{header|6502 Assembly}}==
As with other low-level languages, 6502 assembler has subroutines rather than functions in the strict sense. This implementation of <tt>MULTIPLY</tt> behaves rather like a function, however: it expects two 'parameters' to be passed in the index registers <tt>X</tt> and <tt>Y</tt> and it returns the answer in the accumulator. Note that the 6502 has no <tt>MUL</tt> instruction, so multiplication is carried out by repeated addition.
<
TXA ; so use a memory address
MULLOOP: DEY
Line 73:
CPY #$01
BNE MULLOOP
RTS</
An alternative implementation that multiplies A by X and checks if A/X is zero.
<
; Multiplies A by X
Line 96:
MAIN: LDA #50
LDX #5
JSR MULTIPLY</
=={{header|68000 Assembly}}==
What values are returned (if any) and where they are returned, will depend on the calling convention used. Code written by a C compiler will typically pass parameters onto the stack and use a "frame pointer" to reference them. For this simple example, the operands will be passed into the function using the registers <code>D0</code> and <code>D1</code>, and the output will be in <code>D0</code>. A function is called by using <code>JSR foo</code> where <code>foo</code> is a labeled section of code or a 24-bit memory address. Execution will continue along starting at that address, until an <code>RTS</code> is encountered, at which point the return address will be popped off the stack into the program counter.
<
MOVE.L D1,#$0400
Line 113:
MULU D0,D1
RTS
</syntaxhighlight>
=={{header|8051 Assembly}}==
Like other assembly languages, 8051 doesn't have functions but instead has symbolic references to code. Function arguments are passed via registers decided on beforehand.
<
mov a, #100
mov b, #10
Line 129:
multiply:
mul ab
ret</
=={{header|8086 Assembly}}==
A function is nothing more than a named section of code. A <code>CALL</code> instruction will push the current value of the instruction pointer and then set the instruction pointer to that address. Execution will continue forward until a <code>RET</code> statement is encountered, at which point the top of the stack is popped into the instruction pointer register. Note that the <code>RET</code> statement assumes that the top of the stack contains the actual return address, even though in reality this may not be the case. There is no validation that the return address is correct! This is why it's important for the assembly programmer to ensure the stack is balanced at all times, otherwise your program will go running off to who knows where.
It's important to remember that, unlike other languages, execution of assembly code (and this is true for all assembly languages, not just the 8086) is on a purely linear path by default, much like in other "primitive" languages like BASIC, and so there is nothing stopping the instruction pointer from "falling into" subroutines. Often this can be handy if you're trying to code a variation on a function whose only difference is doing a few extra things at the beginning, but it's something you'll need to guard against, either with a return to the operating system or an infinite loop.
<syntaxhighlight lang="asm">start:
mov al, 0x04
mov bl, 0x05
call multiply
;at this point in execution, the AX register contains 0x0900.
;more code goes here, ideally with some sort of guard against "fallthrough" into multiply.
; somewhere far away from start
multiply:
mul bl ;outputs 0x0014 to ax
ret</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program functMul64.s */
Line 189 ⟶ 206:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|ACL2}}==
<
=={{header|ActionScript}}==
<
return a * b;
}</
=={{header|Ada}}==
<
and an implementation of:
<
begin
return A * B;
end Multiply;</
The Ada 2012 standard provides an even simpler way to define and implement functions:
<
Ada supports generic functions which can take generic formal parameters like the numeric type to use:
<
type Number is digits <>;
function Multiply (A, B : Number) return Number;</
implemented as:
<
begin
return A * B;
end Multiply;</
To use this, you need to instantiate the function for each type e.g.
<
with Multiply;
...
Line 231 ⟶ 248:
type My_Integer is Range -100..100;
function Multiply_My_Integer is new Multiply(My_Integer);
</syntaxhighlight>
=={{header|Aime}}==
<
multiply(real a, real b)
{
return a * b;
}</
=={{header|ALGOL 60}}==
Line 260 ⟶ 277:
=={{header|ALGOL 68}}==
<
(
a * b
)</
=={{header|ALGOL W}}==
<
begin
a * b
end</
=={{header|ALGOL-M}}==
This implementation takes two integers and returns an integer. Note that a function is distinguished from a procedure, which does not return a value.
<
INTEGER A, B;
BEGIN
MULTIPLY := A * B;
END;</
=={{header|Amazing Hopper}}==
Hopper has no functions, but they can be declared with macros, which are resolved at compile time. Access to the working stack is global, but "local" variables can be declared in program segments written after the ".locals" clause. Let's look at some examples of declaring "functions".
<syntaxhighlight lang="c">
/* this need data into stack */
#context Multiplication
mul
Return \\
#synon Multiplication *getproduct
#context-free anothermul
/* #defn Args(*) #GENCODE $$$*$$$ #REVLIST=0,mov(#REVLIST);#ENDGEN, */
Args 'a,b'
Return ( #(a*b) )\\
#synon anothermul *getanotherproduct
#include <jambo.h>
#prototype _multiply(_X_,_Y_)
#synon __multiply Multiply
Main
/* "prototipos" of functions and procedures.
Solves internaly */
Printnl ( Multiply ( 10, 4 ) )
Printnl ( __multiply ( 10, 4 ) )
/* definición alternativa 1 */
Printnl ( Set' 10,4 ', Gosub ' Multiply2 ')
/* aseembler Hopper 1 */
{10,4} jsub( Multiply3 ), {"\n"} print
/* assembler Hopper 2 */
{10,4} jsub( Multiply4 ), {"\n"} print
/* context */
Set '10,4', now get product, and print with newline
/* context-free */
Set '10,4', and get another product; then print with newline
End
.locals /* Subrutines */
_multiply(a,b)
Return ( Mul(a,b) )
/* Define is macro. Others macros: Function, Procedure:
#defn Define(_F_,*) _F_:,#GENCODE $$$*$$$ #REVLIST=0;mov(#REVLIST);#ENDGEN;
#defn Function(_F_,*) _F_:,#GENCODE $$$*$$$ #REVLIST=0;mov(#REVLIST);#ENDGEN;
#defn Procedure(_F_,*) _F_:,#GENCODE $$$*$$$ #REVLIST=0;mov(#REVLIST);#ENDGEN;
*/
Define 'Multiply2, a,b'
Return ( Mul(a,b) )
Multiply3:
b=0, mov(b), a=0, mov(a)
{a,b}mul /* result into stack */
Return
Multiply4:
mul /* get values from stack,
and put result into stack */
back /* Return */
</syntaxhighlight>
{{out}}
<pre>
40.000000
40.000000
40.000000
40.000000
40.000000
40.000000
40.000000
</pre>
=={{header|AmigaE}}==
<
-> other statements if needed... here they are not
ENDPROC a*b -> return value
Line 290 ⟶ 384:
PROC main()
WriteF('\d\n', my_molt(10,20))
ENDPROC</
=={{header|AntLang}}==
<
multiply: {x * y}</
Explicit definition has the syntax:
<
Inside functions, the variable args contains the sequence of arguments.
x, y and z contain the first, second and third argument.
Line 302 ⟶ 396:
=={{header|APL}}==
{{works with|GNU_APL}}
<
⍝⍝ APL2 'tradfn' (traditional function)
⍝⍝ This syntax works in all dialects including GNU APL and Dyalog.
Line 311 ⟶ 405:
⍝⍝ A 'dfn' or 'lambda' (anonymous function)
multiply ← {⍺×⍵}
</syntaxhighlight>
{{works with|Dyalog_APL}}
<
⍝⍝ Dyalog dfn (lambda) syntax
multiply ← ×
</syntaxhighlight>
Works on arrays of any rank (any number of dimensions): atoms, lists, tables, etc.
=={{header|AppleScript}}==
<
return a * b
end</
A function in AppleScript is called a "handler". It can take one of three different forms, depending on what the scripter finds most convenient. Calls to it must match the form used in the handler definition
Handler names followed by zero or more parameters within parentheses are called "positional" -- the number and order of the parameters in the caller must match those in the handler definition.
<syntaxhighlight lang="applescript">on multiply(a, b)
return a * b
end multiply
multiply(2, 3)</
AppleScript also offers handlers with "
These prepositions can be used: <code>about, above, against, apart from, around, aside from, at, below, beneath, beside, between, by, for, from, instead of, into, on, onto, out of, over, since, thru, through, and under</code>. Also, <code>of</code> is available, but if used it must be the first parameter.
Example:
<syntaxhighlight lang="applescript">on multiplication of a by b
return a * b
end multiplication
multiplication of 2 by 3 -- Or: (multiplication by 3) of 2, or: 2's (multiplication by 3)</
Labeled parameters don't need to be in the same order in the calls as in the handler definition, but <code>of</code>, if used, is regarded as a direct parameter and requires some parenthesis if it's not given first or if the context isn't entirely clear.
Line 345 ⟶ 445:
For the past few years, handlers with "interleaved" parameters have also been possible. They're a development from AppleScriptObjectiveC and coders can specify their own labels provided these aren't reserved words. Calls to these handlers must reference the handlers' "owners", which are usually represented within the same script by the keyword <code>my</code>. The parameter order is the same in the calls as in the handler definitions:
<
return a * b
end multiply:|by|:
my multiply:2 |by|:3</
=={{header|Argile}}==
<
.: multiply <real a, real b> :. -> real {a * b}</
with a macro and a variable number of parameters:
<
=: multiply <real a> [<real b>...] := -> real {Cgen a (@@1 (Cgen " * " b))}</
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program functMul.s */
Line 508 ⟶ 598:
</syntaxhighlight>
=={{header|ArnoldC}}==
<
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE a
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE b
Line 522 ⟶ 612:
ENOUGH TALK
I'LL BE BACK product
HASTA LA VISTA, BABY</
=={{header|Arturo}}==
<
print multiply 3 7
Line 534 ⟶ 624:
print multiply2 3 7
</syntaxhighlight>
{{out}}
Line 542 ⟶ 632:
=={{header|AutoHotkey}}==
<
multiply(multiplicand, multiplier) {
Return (multiplicand * multiplier)
}</
=={{header|AutoIt}}==
<
$I=11
$J=12
Line 555 ⟶ 645:
Func product($a,$b)
Return $a * $b
EndFunc</
=={{header|AWK}}==
<
{
return a*b
Line 564 ⟶ 654:
BEGIN {
print multiply(5, 6)
}</
=={{header|Axe}}==
<
r₁*r₂
Return</
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
In ANSI BASIC, functions can be defined as either formulas or multi-line external or internal subroutines. External functions are independent program units that can be called from within the program. Internal functions are considered part of the program unit they are contained in and can only be called from within that unit. External functions do not share any information with other program units and exchange information through parameters and returned values. Internal functions share everything with their surrounding program unit except for their parameters. Internal functions do not have local variables.
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
100 DEF Multiply(A, B) = A * B
110 DECLARE FUNCTION MultiplyI
120 DECLARE EXTERNAL FUNCTION MultiplyE
130 PRINT Multiply(3, 1.23456)
140 PRINT MultiplyI(3, 1.23456)
150 PRINT MultiplyE(3, 1.23456)
160 FUNCTION MultiplyI(X, Y)
170 LET MultiplyI = X * Y
180 END FUNCTION
190 END
200 EXTERNAL FUNCTION MultiplyE(A, B)
210 LET MultiplyE = A * B
220 END FUNCTION
</syntaxhighlight>
{{out}}
<pre>
3.70368
3.70368
3.70368
</pre>
==={{header|Applesoft BASIC}}===
Applesoft BASIC functions are unary meaning they only take one argument. As the task asks for a multiply function which takes two arguments this poses a problem. To get around this, the multiply function MU takes one argument as the offset into an array of parameters.
Function names in Applesoft BASIC can be longer than two characters but only the first two characters are significant. Function names cannot contain any keywords.
<syntaxhighlight lang="basic">10 DEF FN MULTIPLY(P) = P(P) * P(P+1)
20 P(1) = 611 : P(2) = 78 : PRINT FN MULTIPLY(1)</syntaxhighlight>
<syntaxhighlight lang="basic">47658</syntaxhighlight>
==={{header|BASIC256}}===
<
return a * b
end function</
==={{header|BBC BASIC}}===
BBC BASIC supports both single-line and multi-line function definitions. Note that the function name ''must'' begin with '''FN'''.
Single-line function:
<syntaxhighlight lang="bbcbasic">PRINT FNmultiply(6,7)
END
DEF FNmultiply(a,b) = a * b</syntaxhighlight>
Multiline function:
<syntaxhighlight lang="bbcbasic">DEF FNmultiply(a,b)
LOCAL c
c = a * b
= c</syntaxhighlight>
=== {{header|Chipmunk Basic}} ===
<syntaxhighlight lang="basic">
10 rem Function definition
20 rem ** 1. Function defined as formula. An obsolete way - does not work properly with integer formal parameters (e.g. x%).
30 def fnmultiply(a, b) = a * b
40 rem ** Call the functions
50 print multiply(3,1.23456)
60 print fn multiply(3,1.23456)
70 end
200 rem ** 2. Function defined as subroutine returning a value
210 sub multiply(a,b)
220 multiply = a*b
230 end sub
</syntaxhighlight>
{{out}}
<pre>
3.70368
3.70368
</pre>
==={{header|Commodore BASIC}}===
In Commodore BASIC function definition can consist of any mathematical operation other functions or commands which result in a numeric expression. The definition is limited to single statement, and it accepts only a single argument. When using the function, keyword fn must precede the function name, which itself must be uniquely distinguishable by its first two characters.
<
20 Y = 4 : REM VALUE OF SECOND ARGUMENT MUST BE ASSIGNED SEPARATELY
30 PRINT FN MULT(3)</
==={{header|
<syntaxhighlight lang="creative basic">
DECLARE Multiply(N1:INT,N2:INT)
DEF A,B:INT
A=2:B=2
OPENCONSOLE
PRINT Multiply(A,B)
PRINT:PRINT"Press any key to close."
DO:UNTIL INKEY$<>""
CLOSECONSOLE
END
SUB Multiply(N1:INT,N2:INT)
DEF Product:INT
Product=N1*N2
RETURN Product
'Can also be written with no code in the subroutine and just RETURN N1*N2.
</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
Function multiply(d1 As Double, d2 As Double) As Double
Return d1 * d2
End Function</syntaxhighlight>
This function could either be used for all numeric types (as they are implicitly convertible to Double)
or could be overloaded to deal with each such type (there are 12 of them).
Alternatively, one could write a macro though this wouldn't be type-safe:
<syntaxhighlight lang="freebasic">#Define multiply(d1, d2) (d1) * (d2)</syntaxhighlight>
==={{header|FutureBasic}}===
<syntaxhighlight lang="futurebasic">window 1
local fn multiply( a as long, b as long ) as long
end fn = a * b
print fn multiply( 3, 9 )
HandleEvents</syntaxhighlight>
Output:
<pre>
27
</pre>
==={{header|Gambas}}===
'''[https://gambas-playground.proko.eu/?gist=bc93236474d9937217dd4117026f7441 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Print Multiply(56, 4.66)
End
Public Sub Multiply(f1 As Float, f2 As Float) As Float
Return f1 * f2
End</syntaxhighlight>
Output:
<pre>
260.96
</pre>
==={{header|
{{works with|BASICA}}
<
20 PRINT FNMULT(5,6)
39 END
</syntaxhighlight>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 DEF MULTIPLY(A,B)=A*B</syntaxhighlight>
==={{header|IWBASIC}}===
<syntaxhighlight lang="iwbasic">
'1. Not Object Oriented Program
DECLARE Multiply(N1:INT,N2:INT),INT
DEF A,B:INT
A=2:B=2
OPENCONSOLE
PRINT Multiply(A,B)
PRINT
'When compiled as a console only program, a press any key to continue is automatic.
CLOSECONSOLE
END
SUB Multiply(N1:INT,N2:INT),INT
DEF Product:INT
Product=N1*N2
RETURN Product
ENDSUB
'Can also be written with no code in the subroutine and just RETURN N1*N2.
----
'2. Not Object Oriented Program Using A Macro
$MACRO Multiply (N1,N2) (N1*N2)
DEF A,B:INT
A=5:B=5
OPENCONSOLE
PRINT Multiply (A,B)
PRINT
'When compiled as a console only program, a press any key to continue is automatic.
CLOSECONSOLE
END
----
'3. In An Object Oriented Program
CLASS Associate
'functions/methods
DECLARE Associate:'object constructor
DECLARE _Associate:'object destructor
'***Multiply declared***
DECLARE Multiply(UnitsSold:UINT),UINT
'members
DEF m_Price:UINT
DEF m_UnitsSold:UINT
DEF m_SalesTotal:UINT
ENDCLASS
DEF Emp:Associate
m_UnitsSold=10
Ass.Multiply(m_UnitsSold)
OPENCONSOLE
PRINT"Sales total: ",:PRINT"$"+LTRIM$(STR$(Emp.m_SalesTotal))
PRINT
CLOSECONSOLE
END
'm_price is set in constructor
SUB Associate::Multiply(UnitsSold:UINT),UINT
m_SalesTotal=m_Price*UnitsSold
RETURN m_SalesTotal
ENDSUB
SUB Associate::Associate()
m_Price=10
ENDSUB
SUB Associate::_Associate()
'Nothing to cleanup
ENDSUB
</syntaxhighlight>
==={{header|Liberty BASIC}}===
{{works with|Just BASIC}}
<syntaxhighlight lang="lb">' define & call a function
print multiply( 3, 1.23456)
wait
function multiply( m1, m2)
multiply =m1 *m2
end function
end</syntaxhighlight>
==={{header|Locomotive Basic}}===
<syntaxhighlight lang="locobasic">10 DEF FNmultiply(x,y)=x*y
20 PRINT FNmultiply(2,PI)</syntaxhighlight>
Function names are always preceded by "FN" in Locomotive BASIC. Also, PI is predefined by the interpreter as 3.14159265.
==={{header|OxygenBasic}}===
<syntaxhighlight lang="text">
'SHORT FORMS:
float multiply(float a,b) = a * b
Line 618 ⟶ 968:
'TEST:
print multiply(pi,2) '6.28...
</syntaxhighlight>
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">Procedure multiply(a,b)
ProcedureReturn a*b
EndProcedure</syntaxhighlight>
==={{header|QBasic}}===
<
'(as they are implicitly convertible to Double)
FUNCTION multiply# (a AS DOUBLE, b AS DOUBLE)
Line 632 ⟶ 987:
PRINT multiply(3, 1.23456)
PRINT FNmultiply#(3, 1.23456)</
{{out}}
<pre> 3.703680038452148</pre>
==={{header|QuickBASIC}}===
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">DECLARE FUNCTION multiply% (a AS INTEGER, b AS INTEGER)
FUNCTION multiply% (a AS INTEGER, b AS INTEGER)
multiply = a * b
END FUNCTION</syntaxhighlight>
==={{header|REALbasic}}===
<syntaxhighlight lang="vb">
Function Multiply(a As Integer, b As Integer) As Integer
Return a * b
End Function
</syntaxhighlight>
==={{header|S-BASIC}}===
S-BASIC is unusual in that the function return value is assigned to the END statement that terminates the function.
<syntaxhighlight lang="basic">
function multiply(a, b = integer) = integer
end = a * b
rem - exercise the function
print "The product of 9 times 3 is"; multiply(9, 3)
end
</syntaxhighlight>
{{out}}
<pre>
The product of 9 times 3 is 27
</pre>
==={{header|SmallBASIC}}===
<syntaxhighlight lang="qbasic">
func multiply(a, b)
return a * b
end
print "2 * 3 = "; multiply(2, 3)
</syntaxhighlight>
If function definition is only one line, <code>def</code> can be used:
<syntaxhighlight lang="qbasic">
def multiply(a, b) = a * b
print "2 * 3 = "; multiply(2, 3)
</syntaxhighlight>
==={{header|True BASIC}}===
The <code>FUNCTION</code> and <code>DEF</code> commands are synonymous and can be interchanged.
<
LET multiply = a * b
END FUNCTION
Line 646 ⟶ 1,049:
DEF multiply (a, b) = a * b
END</
==={{header|TI-89 BASIC}}===
<syntaxhighlight lang="ti89b">multiply(a, b)
Func
Return a * b
EndFunc</syntaxhighlight>
==={{header|uBasic/4tH}}===
In uBasic you can turn any subroutine into a function with the '''FUNC()''' function. It takes one argument, which is the label. Arguments are optional.
<syntaxhighlight lang="text">Print FUNC(_multiply (23, 65))
End
_multiply Param (2) : Return (a@ * b@)</syntaxhighlight>
==={{header|VBA}}===
<syntaxhighlight lang="vb">Function Multiply(lngMcand As Long, lngMplier As Long) As Long
Multiply = lngMcand * lngMplier
End Function</syntaxhighlight>
To use this function :
<syntaxhighlight lang="vb">Sub Main()
Dim Result As Long
Result = Multiply(564231, 897)
End Sub</syntaxhighlight>
==={{header|VBScript}}===
<syntaxhighlight lang="vb">function multiply( multiplicand, multiplier )
multiply = multiplicand * multiplier
end function</syntaxhighlight>
Usage:
<syntaxhighlight lang="vb">dim twosquared
twosquared = multiply(2, 2)</syntaxhighlight>
==={{header|Visual Basic}}===
{{works with|Visual Basic|VB6 Standard}}
<syntaxhighlight lang="vb">
Function multiply(a As Integer, b As Integer) As Integer
multiply = a * b
End Function
</syntaxhighlight>
Call the function
<syntaxhighlight lang="vb">Multiply(6, 111)</syntaxhighlight>
==={{header|Visual Basic .NET}}===
<syntaxhighlight lang="vbnet">Function Multiply(ByVal a As Integer, ByVal b As Integer) As Integer
Return a * b
End Function</syntaxhighlight>
Call the function
<syntaxhighlight lang="vbnet">Multiply(1, 1)</syntaxhighlight>
==={{header|Yabasic}}===
<
return a * b
end sub</
==={{header|Xojo}}===
<syntaxhighlight lang="vbnet">Function Multiply(ByVal a As Integer, ByVal b As Integer) As Integer
Return a * b
End Function</syntaxhighlight>
Call the function
<syntaxhighlight lang="vbnet">Dim I As Integer = Multiply(7, 6)</syntaxhighlight>
==={{header|ZX Spectrum Basic}}===
On the ZX Spectrum, function names are limited to one letter. Note that the function becomes effective as soon as it is entered into the program, and does not need to be run
<syntaxhighlight lang="zxbasic">10 PRINT FN m(3,4): REM call our function to produce a value of 12
20 STOP
9950 DEF FN m(a,b)=a*b</syntaxhighlight>
=={{header|Batch File}}==
Windows batch files only have procedures, not functions. Instead, environmental variables can be used as a global shared state.
<syntaxhighlight lang="text">@ECHO OFF
SET /A result = 0
CALL :multiply 2 3
Line 665 ⟶ 1,129:
GOTO :eof
:eof</
=={{header|bc}}==
{{Works with|GNU bc}}
<
print multiply(2, 3)</
=={{header|BCPL}}==
A function is simply defined as an expression in terms of its arguments.
<
Defining a block of code that executes some statements and then returns a
Line 696 ⟶ 1,146:
to define a function containing imperative statements. When used this way,
it is equivalent to the functions in most other imperative languages.
<
$( // any imperative statements could go here
resultis a * b
$)</
=={{header|BlitzMax}}==
<syntaxhighlight lang="blitzmax">function multiply:float( a:float, b:float )
return a*b
end function
print multiply(3.1416, 1.6180)</syntaxhighlight>
{{out}}<pre>5.08310890</pre>
=={{header|Boo}}==
<
return x * y
print multiply(3, 2)</
=={{header|Binary Lambda Calculus}}==
In lambda calculus, multiplication on Church numerals is <code>mul = \m \n \f. m (n f)</code> which in BLC is
<pre>00 00 00 01 1110 01 110 10</pre>
If mul is used several times within an expression E, then they can share the same definition by using <code>(\mul. E)(\m\n\f. m (n f))</code>. For example, the cube function is <code>\n. (\mul. mul n (mul n n)) (\m\n\f. m (n f))</code> which in BLC is
<pre>00 01 00 01 01 10 110 01 01 10 110 110 0000000111100111010</pre>
=={{header|BQN}}==
Tacit definition:
<syntaxhighlight lang
With names:
<syntaxhighlight lang
=={{header|Bracmat}}==
<
out$multiply$(123456789.987654321); { writes 121932631112635269 to standard output }</
=={{header|Brat}}==
<
p multiply 3 14 #Prints 42</
=={{header|C}}==
<
{
return a * b;
}</
===Macros===
Macros can be defined at the top of a program and the compiler will replace the function calls with the function itself before compiling the program (the source file will not change).
<
Parentheses should be added around parameters in the function definition to avoid order of operations errors when someone uses the macro as such:
<
A program with that call would be compiled as if this were coded instead:
<
Another advantage of macros is that they work with all types alike. For example, the above macro can be used both to multiply double values (like the function above), and to multiply int values (giving an int, which the function doesn't).
=={{header|C sharp|C#}}==
<
{
return a * b;
}</
Anonymous function:
<
=={{header|C++}}==
Line 749 ⟶ 1,218:
An inline function differs from the normal function by the keyword inline and the fact that it has to be included in every translation unit which uses it (i.e. it normally is written directly in the header). It allows the compiler to eliminate the function without having the disadvantages of macros (like unintended double evaluation and not respecting scope), because the substitution doesn't happen at source level, but during compilation. An inline version of the above function is:
<
{
return a*b;
}</
If not only doubles, but numbers of arbitrary types are to be multiplied, a function template can be used:
<
Number multiply(Number a, Number b)
{
return a*b;
}</
Of course, both inline and template may be combined (the <tt>inline</tt> then has to follow the <tt>template<...></tt>), but since templates have to be in the header anyway (while the standard allows them to be compiled separately using the keyword <tt>export</tt>, almost no compiler implements that), the compiler usually can inline the template even without the keyword.
Since C++20, the template parameters can be inferred using <tt>auto</tt>:
<
{
return a*b;
}</
=={{header|Chapel}}==
<syntaxhighlight lang="text">
proc multiply(a, b)
{
return a * b;
}
</syntaxhighlight>
Can require that the two arguments be of the same type.
<syntaxhighlight lang="text">
proc multiply(a : ?t ... 2)
{
return a(0) * a(1)
}
</syntaxhighlight>
Will work on any type where the * operator is defined.
=={{header|ChucK}}==
<syntaxhighlight lang="text">
fun float multiply (float a, float b)
{
Line 775 ⟶ 1,263:
// uncomment next line and change values to test
//<<< multiply(16,4) >>>;
</syntaxhighlight>
=={{header|Clay}}==
<
=={{header|Clojure}}==
<
(* x y))
(multiply 4 5)</
Or with multiple arities (in the manner of the actual <tt>*</tt> function):
<
([] 1)
([x] x)
Line 793 ⟶ 1,281:
(reduce * (* x y) more)))
(multiply 2 3 4 5) ; 120</
=={{header|CLU}}==
The following is a function that multiplies two integers and ignores any error conditions
(as most examples do).
<
return(a * b)
end multiply</
The following is a type-parameterized function that wraps the built-in multiplication operator
Line 806 ⟶ 1,294:
It also shows the complete syntax of a function definition (type parameterization,
signals, and a <code>where</code> clause).
<
signals (overflow, underflow)
where T has mul: proctype (T, T) returns (T)
signals (overflow, underflow)
return(a * b) resignal overflow, underflow
end multiply</
=={{header|COBOL}}==
In COBOL, ''multiply'' is a reserved word, so the requirements must be relaxed to allow a different function name.
{{
The following uses a subprogram:
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. myTest.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 x
01 y
01 z
PROCEDURE DIVISION.
CALL "myMultiply" USING
Line 835 ⟶ 1,324:
DATA DIVISION.
LINKAGE SECTION.
01 x
01 y
01 z
PROCEDURE DIVISION USING BY REFERENCE x, y, z.
MULTIPLY x BY y GIVING z.
EXIT PROGRAM.
END PROGRAM myMultiply.</
{{Works with|COBOL 2002}}
This example uses user-defined functions.
<
PROGRAM-ID. myTest.
ENVIRONMENT DIVISION.
Line 853 ⟶ 1,342:
DATA DIVISION.
WORKING-STORAGE SECTION.
01 x
01 y
PROCEDURE DIVISION.
DISPLAY myMultiply(x, y).
Line 864 ⟶ 1,353:
DATA DIVISION.
LINKAGE SECTION.
01 x
01 y
01 z
PROCEDURE DIVISION USING x, y RETURNING z.
MULTIPLY x BY y GIVING z.
END FUNCTION myMultiply.</
=={{header|Coco}}==
Line 876 ⟶ 1,365:
As CoffeeScript. In addition, Coco provides some syntactic sugar for accessing the <code>arguments</code> array reminiscent of Perl's <code>@_</code>:
<
Furthermore, when no parameter list is defined, the first argument is available as <code>it</code>:
<
=={{header|CoffeeScript}}==
<
=={{header|ColdFusion}}==
====Tag style====
<syntaxhighlight lang="coldfusion"><cffunction name="multiply" returntype="numeric">
<cfargument name="a" type="numeric">
<cfargument name="b" type="numeric">
<cfreturn a * b>
</cffunction></
====Script style====
<syntaxhighlight lang="lisp">numeric function multiply(required numeric a, required numeric b){
return a * b;
}
</syntaxhighlight>
=={{header|Common Lisp}}==
Line 896 ⟶ 1,393:
===Ordinary Functions===
Ordinary functions operate on the values of argument expressions. Lisp functions terminate by returning one or more values, or by executing a non-local dynamic control transfer, in which case values are not returned.
<
(* a b))
(multiply 2 3)</
====User-Defined Compiler Optimization of Functions====
In Lisp we can express optimizations of calls to a function using compiler macros. For instance, suppose we know that the multiply function, which may be in another module, simply multiplies numbers together. We can replace a call to multiply by a constant, if the arguments are constant expressions. Like the usual kind of Lisp macro, the compiler macro takes the argument forms as arguments, not the argument values. The special keyword &whole gives the macro access to the entire expression, which is convenient for the unhandled cases, whereby no transformation takes place:
<
(if (and (constantp a) (constantp b))
(* (eval a) (eval b))
expr)) ;; no macro recursion if we just return expr; the job is done! </
Lisp implementations do not have to honor compiler macros. Usually compilers make use of them, but evaluators do not.
Line 938 ⟶ 1,435:
Also, the DEFGENERIC is optional, since the first DEFMETHOD will define the generic function, but good practice.
<
;;; terrific example coming
</syntaxhighlight>
=={{header|Cowgol}}==
<
rslt := a * b;
end sub</
=={{header|D}}==
<
int multiply1(int a, int b) {
return a * b;
Line 1,002 ⟶ 1,468:
import std.stdio;
writeln("2 * 3 = ", result);
}</
Both the compile-time and run-time output:
<pre>6
Line 1,008 ⟶ 1,474:
=={{header|Dart}}==
<
print(multiply(1,2));
print(multiply2(1,2));
Line 1,025 ⟶ 1,491:
return num1 * num2;
}
</syntaxhighlight>
=={{header|dc}}==
For dc, the functions (called macros) are limited to names from 'a' to 'z'
Create a function called 'm'
<syntaxhighlight lang
Use it (lm loads the function in 'm',x executes it, f shows the the stack.)
<
= 12</
=={{header|Delphi}}==
In addition to what is shown in the section [[#Pascal|Pascal]], the following is possible too:
<syntaxhighlight lang="delphi">function multiply(a, b: integer): integer;
begin
end;</
=={{header|Diego}}==
<syntaxhighlight lang="diego">begin_funct({number}, multiply)_param({number}, a, b);
with_funct[]_calc([a]*[b]);
end_funct[];
me_msg()_funct(multiply)_param(1,2);</syntaxhighlight>
=={{header|DM}}==
Functions (called procs) may be derived from <code>proc</code>.
<syntaxhighlight lang="dm">proc/multiply(a, b)
return a * b
</syntaxhighlight>
=={{header|Draco}}==
Line 1,046 ⟶ 1,526:
return type of the function.
<
a * b
corp</
=={{header|Dragon}}==
<
return a*b
}</
=={{header|DWScript}}==
<
begin
Result := a * b;
end;</
=={{header|Dyalect}}==
<
a * b
}</
Using lambda syntax:
<
=={{header|Déjà Vu}}==
<
* a b</
=={{header|E}}==
<
return a * b
}</
(This does not necessarily return a product, but whatever the "multiply" method of <var>a</var> returns. The parameters could be guarded to only accept standard numbers.)
It is also possible to write short anonymous function definitions which do not need explicit returns:
<
This definition is identical to the previous except that the function object will not know its own name.
=={{header|EasyLang}}==
<syntaxhighlight lang="text">
func
return a * b
.
</syntaxhighlight>
=={{header|EchoLisp}}==
<
(define (multiply a b) (* a b)) → multiply ;; (1)
(multiply 1/3 666) → 222
Line 1,118 ⟶ 1,599:
multiply → (λ (_a _b) (#🔶_multiply)) ;; compiled function
</syntaxhighlight>
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">
module MultiplyExample {
static <Value extends Number> Value multiply(Value n1, Value n2) {
return n1 * n2;
}
void run() {
(Int i1, Int i2) = (7, 3);
Int i3 = multiply(i1, i2);
(Double d1, Double d2) = (2.7182818, 3.1415);
Double d3 = multiply(d1, d2);
@Inject Console console;
console.print($"{i1}*{i2}={i3}, {d1}*{d2}={d3}");
}
}
</syntaxhighlight>
{{out}}
<pre>
7*3=21, 2.7182818*3.1415=8.539482274700001
</pre>
=={{header|Efene}}==
<
A * B
}
Line 1,128 ⟶ 1,632:
run = fn () {
io.format("~p~n", [multiply(2, 5)])
}</
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
multiply(a, b: INTEGER): INTEGER
do
Result := a*b
end
</syntaxhighlight>
=={{header|Ela}}==
<
Anonymous function:
<
=={{header|Elena}}==
<
= a * b;</
Anonymous function / closure:
<
Root closure:
<
=={{header|Elixir}}==
<
def multiply(x,y) do
x * y
Line 1,160 ⟶ 1,664:
end
RosettaCode.task</
{{out}}
Line 1,168 ⟶ 1,672:
=={{header|Elm}}==
<syntaxhighlight lang="elm">
--There are multiple ways to create a function in Elm
Line 1,176 ⟶ 1,680:
--This is an anonymous function
\x y -> x*y
</syntaxhighlight>
=={{header|Emacs Lisp}}==
<
(* x y))</
A "docstring" can be added as follows. This is shown by the Emacs help system and is good for human users. It has no effect on execution.
<
"Return the product of X and Y."
(* x y))</
=={{header|EMal}}==
<syntaxhighlight lang="emal">
fun multiply = var by var a, var b
return a * b
end
writeLine(multiply(6, 7))
writeLine(multiply("can", 2))
</syntaxhighlight>
{{out}}
<pre>
42
cancan
</pre>
=={{header|Erlang}}==
===Using case, multiple lines===
<
-module(func_definition).
-export([main/0]).
Line 1,201 ⟶ 1,719:
case {A,B} of
{A, B} -> A * B
end.</
{{out}}
<pre>12
Line 1,207 ⟶ 1,725:
</pre>
===In a single line===
<
-module(func_definition).
-export([main/0]).
Line 1,215 ⟶ 1,733:
io :format("~p~n",[K]).
multiply(A,B) -> A * B.</
The output is the same.
Line 1,249 ⟶ 1,767:
=={{header|Euphoria}}==
<
return a * b
end function</
If you declare the arguments as <code>object</code> then sequence comprehension kicks in:
<
return a * b
end function
Line 1,264 ⟶ 1,782:
? multiply( a, b )
? multiply( a, 7 )
? multiply( 10.39564, b )</
{{out}}
<pre>81
Line 1,274 ⟶ 1,792:
=={{header|F Sharp|F#}}==
The default will be an integer function but you can specify other types as shown:
<
let fmultiply (x : float) (y : float) = x * y</
=={{header|Factor}}==
<
=={{header|Falcon}}==
<
> "Hi ", name
end</
=={{header|FALSE}}==
<
m: {binding the function to one of the 26 available symbol names}
2 3m;! {executing the function, yielding 6}</
=={{header|Fantom}}==
<
{
public static Void main ()
Line 1,298 ⟶ 1,816:
echo ("Multiply 2 and 4: ${multiply(2, 4)}")
}
}</
=={{header|Fermat}}==
<
=={{header|Fexl}}==
<
Or if I'm being cheeky:
<
=={{header|Fish}}==
Functions cannot be named in Fish. However, they can be defined as new stacks that pull a certain number of arguments off the stack that came before. <code>2[</code> says pull 2 values off the stack and put them in a new, separate stack. <code>]</code> says put all remaining values in the current stack onto the top of the stack below (the old stack).
<syntaxhighlight lang
=={{header|Forth}}==
<
: multiply ( a b -- c ) * ;</
=={{header|Fortran}}==
In FORTRAN I (1957), inline function could be defined at the beginning of the program. Let's note than to specify a floating point real the name of the statement function begins with an X (no type declaration) and to specify this is a function the name ends with a F.
<
And for interger multiplication:
<
In FORTRAN IV, FORTRAN 66 or later, define a function:
<
REAL MULTIPLY, X, Y
MULTIPLY = X * Y
END</
And for integer multiplication:
<
INTEGER MULTINT, X, Y
MULTINT = X * Y
END</
In Fortran 95 or later, define an elemental function, so that this function can be applied to whole arrays as well as to scalar variables:
<
contains
elemental function multiply(x, y)
Line 1,341 ⟶ 1,859:
multiply = x * y
end function multiply
end module elemFunc</
<
use elemFunc
Line 1,351 ⟶ 1,869:
z = multiply(x,y) ! element-wise invocation only works with elemental function
end program funcDemo</
It is worth noting that Fortran can call functions (and subroutines) using named arguments; e.g. we can call multiply in the following way:
<
z = multiply(y=x, x=y) ! the same as multiply(y, x)</
(Because of commutativity property of the multiplication, the difference between <code>multiply(x,y)</code> and <code>multiply(y,x)</code> is not evident)
Also note that the function result can be declared with a different name within the routine:
<
contains
elemental function multiply(x, y) result(z)
Line 1,365 ⟶ 1,883:
z = x * y
end function multiply
end module elemFunc</
=={{header|
Free Pascal allows everything what [[#Delphi|Delphi]] allows.
Note, using the special variable “<tt>result</tt>” requires <tt>{$modeSwitch result+}</tt>.
This is the default in <tt>{$mode objFPC}</tt> and <tt>{$mode Delphi}</tt>.
Furthermore, after the assignment to the return variable further statements may follow.
To ensure a value is returned immediately and no further following statements are processed, using the built-in <tt>exit</tt> procedure is possible too in <tt>{$mode objFPC}</tt>:
<syntaxhighlight lang="delphi">function multiply(a, b: integer): integer;
begin
exit(a * b);
end;</syntaxhighlight>
If <tt>exit</tt> has been redefined in the current scope, its special meaning can be accessed via the fully-qualified identifier <tt>system.exit</tt>.
Note, any enclosing <tt>finally</tt> frames of <tt>try … finally … end</tt> are processed first before actually returning from the <tt>function</tt>.
As a consequence of that, <tt>exit</tt> may not appear within a <tt>finally</tt> frame.
=={{header|Frink}}==
This function works correctly with any combination of arbitrarily-large integers, arbitrary-precision floating point numbers, arbitrary-size rational numbers, complex numbers, intervals of real numbers, and even numbers with units of measure (e.g. <code>multiply[1 watt, 1 s]</code> gives an answer with dimensions of energy. Frink tries hard to always Do The Right Thing with math and numerics and units of measure.
<syntaxhighlight lang="frink">multiply[x,y] := x*y</syntaxhighlight>
=={{header|Futhark}}==
<syntaxhighlight lang="futhark">
let multiply (x: i32, y: i32) : i32 = x * y
</syntaxhighlight>
=={{header|GAP}}==
<
return a*b;
end;</
=={{header|GML}}==
In GML one can not define a function but in [[Game Maker]] there is a ''script'' resource, which is the equivalent of a function as defined here. Scripts can be exported to or imported from a text file with the following format:
<
a = argument0
b = argument1
return(a * b)</
=={{header|Gnuplot}}==
<
# then for example
print multiply(123,456)</
=={{header|Go}}==
Line 1,443 ⟶ 1,932:
The return statement can contain an expression of the function return type:
<
return a * b
}</
Alternatively, if the return value is named, the return statement does not require an expression:
<
z = a * b
return
}</
=={{header|Golfscript}}==
<syntaxhighlight lang
=={{header|Groovy}}==
<
Test Program:
<
{{out}}
<pre>x * y = 20 * 50 = 1000</pre>
=={{header|Halon}}==
<
{
return $a * $b;
}</
=={{header|Haskell}}==
<
Alternatively, with help of auto-currying,
<
You can use [[lambda-function]]
<
=={{header|Haxe}}==
<
return x * y;
}</
=={{header|hexiscript}}==
<
return a * b
endfun</
=={{header|HicEst}}==
<
multiply = a * b
END</
=={{header|HolyC}}==
<
return a * b;
}
Line 1,497 ⟶ 1,986:
F64 x;
x = Multiply(42, 13.37);
Print("%5.2f\n", x);</
=={{header|Hy}}==
Function definition:
<
(* a b))</
Lambda definition:
<
=={{header|i}}==
<syntaxhighlight lang="i">
concept multiply(a, b) {
return a*b
}
</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
<
return a * b
end</
=={{header|IDL}}==
The task description is unclear on what to do when the arguments to the function are non-scalar, so here's multiple versions:
<
return, a* b
end</
If "a" and "b" are scalar, this will return a scalar. If they are arrays of the same dimensions, the result is an array of the same dimensions where each element is the product of the corresponding elements in "a" and "b".
Alternatively, there's this possibility:
<
return, product([a, b])
end</
This will yield the same result for scalars, but if "a" and "b" are arrays it will return the product of all the elements in both arrays.
Finally, there's this option:
<
return, a # b
end</
This will return a scalar if given scalars, if given one- or two-dimensional arrays it will return the matrix-product of these arrays. E.g. if given two three-element one-dimensional arrays (i.e. vectors), this will return a 3x3 matrix.
=={{header|Inform 6}}==
<
return a * b;
];</
=={{header|Inform 7}}==
<
decide on A * B.</
=={{header|Io}}==
<
=={{header|J}}==
<
Works on conforming arrays of any rank (any number of dimensions, as long as the dimensions of one are a prefix of the dimensions of the other): atoms, lists, tables, etc.
Or, more verbosely (and a bit slower, though the speed difference should be unnoticeable in most contexts):
<
x * y
)</
Here we use an [http://www.jsoftware.com/help/dictionary/intro18.htm explicit] definition (where the arguments are named) rather than a [http://www.jsoftware.com/help/dictionary/intro19.htm tacit] version (where the arguments are implied). In explicit J verbs, x is the left argument and y is the right argument.
Line 1,664 ⟶ 2,052:
=={{header|Java}}==
There are no global functions in Java. The equivalent is to define static methods in a class (here invoked as "Math.multiply(a,b)"). Overloading allows us to define the method for multiple types.
<
{
public static int multiply( int a, int b) { return a*b; }
public static double multiply(double a, double b) { return a*b; }
}
</syntaxhighlight>
===Using Java version 8===
Since version 8, Java has various built in Functions with their normal mathematical names.
<syntaxhighlight lang="java">
import java.util.function.BiFunction;
import java.util.function.DoubleUnaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
public final class FunctionDefinition {
public static void main(String[] args) {
System.out.println(size.apply("Rosetta"));
System.out.println(greeting.apply("Joe"));
System.out.println(half.applyAsDouble(7));
System.out.println(lessThanTen.test(15));
System.out.println(add.apply(2, 3));
}
private static Function<String, Integer> size = s -> s.length();
private static UnaryOperator<String> greeting = s -> "Hello " + s;
private static DoubleUnaryOperator half = a -> a / 2;
private static Predicate<Integer> lessThanTen = a -> a < 10;
private static BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
}
</syntaxhighlight>
{{ out }}
<pre>
7
Hello Joe
3.5
false
5
</pre>
=={{header|JavaScript}}==
===ES1-*===
Function Declaration
<
return a*b;
}</
===ES3-*===
Function Expression
<
return a * b;
};</
Named Function Expression
<
return a * b;
};</
Method Definition
<
multiply: function(a, b) {
return a * b;
}
};</
===ES5-*===
Accessors
<
get foo() {
return 1;
Line 1,704 ⟶ 2,133:
// do things with value
}
};</
===ES6-*===
Arrow Function
<
var multiply = (a, b) => { return a * b };
// Or, `var` being long deprecated, and currying convenient,
// (particularly in use with the higher-order Array methods)
const multiply = a =>
b => a * b;
</syntaxhighlight>
Concise Body Method Definition
<
multiply(a, b) {
return a * b;
}
};</
Generator Functions
<
yield 1;
}</
=={{header|Joy}}==
<
=={{header|jq}}==
Example of a simple function definition:<
Example of the definition of an inner function:<
def generate(f): def r: ., (f | r); r;</
The previous example (generate/1) also illustrates that a function argument can be a function or composition of functions. Here is another example:<
<tt>summation/1</tt> expects an array as its input and takes a function, f, as its argument. For example, if the input array consists of JSON objects with attributes "h" and "w", then to compute SIGMA (h * w) we could simply write:<
=={{header|Julia}}==
Line 1,739 ⟶ 2,174:
General function definition:
<
return a * b
end</
Julia also supports `assignment` definition as shorthand:
<
And lambda calculus:
<
=={{header|Kaya}}==
<
// A function definition in Kaya:
Line 1,762 ⟶ 2,197:
Void main() {
putStrLn(string( multiply(2, 3) ));
}</
=={{header|Klingphix}}==
<
2 3 multiply print { 6 }</
=={{header|Kotlin}}==
<
fun multiply(a: Int, b: Int) = a * b
Line 1,776 ⟶ 2,211:
fun multiplyProper(a: Int, b: Int): Int {
return a * b
}</
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def multiply
{lambda {:a :b}
Line 1,796 ⟶ 2,231:
-> 720
</syntaxhighlight>
=={{header|
=== Function decleration ===
<syntaxhighlight lang="lang">
fp.multiply = ($a, $b) -> {
return parser.op($a * $b)
}
</syntaxhighlight>
=== One-line function decleration ===
<syntaxhighlight lang="lang">
fp.multiply = ($a, $b) -> return parser.op($a * $b)
</syntaxhighlight>
=== Function decleration by using operator functions ===
<syntaxhighlight lang="lang">
fp.multiply = fn.mul
</syntaxhighlight>
=== Function decleration by using combinator functions ===
Combinator functions can be called partially, fn.argCnt2 is used to force the caller to provide 2 arguments to prevent partially calling fp.multiply
<syntaxhighlight lang="lang">
fp.multiply = fn.argCnt2(fn.combA2(fn.mul))
</syntaxhighlight>
=== Function decleration with call by pointer ===
<syntaxhighlight lang="lang">
return parser.op($*a * $*b) # Pointers can be dereferenced by using *
}
</syntaxhighlight>
=={{header|langur}}==
<syntaxhighlight>
</syntaxhighlight>
<syntaxhighlight>
val multiply = fn a, b: a * b
</syntaxhighlight>
<syntaxhighlight>
</syntaxhighlight>
=={{header|Lasso}}==
Line 1,835 ⟶ 2,281:
Lasso supports multiple dispatch — signature definitions determine which method will be invoked.
<
return #a * #b
}</
As this function is so simple it can also be represented like so:
<
Using multiple dispatch, different functions will be invoked depending on the functions input.
<
define multiply(a::integer,b::any) => #a * integer(#b)
define multiply(a::decimal,b::any) => #a * decimal(#b)
// Catch all signature
define multiply(a::any,b::any) => decimal(#a) * decimal(#b)</
=={{header|Latitude}}==
Line 1,856 ⟶ 2,302:
Latitude methods are defined using curly braces <code>{}</code> and assigned to variables like any other value. Arguments are implicitly named <code>$1</code>, <code>$2</code>, etc.
<
Calling a method is done either with parentheses or with a colon.
<
multiply: 2, 3.</
If a method is intended to be used as a first-class value or stored in a data structure, the automatic evaluation behavior of methods can be undesired. In this case, one can wrap a method in a <code>Proc</code> with the <code>proc</code> method. <code>Proc</code> objects can then be later called explicitly with <code>call</code>.
<
multiply call (2, 3).
multiply call: 2, 3.</
=={{header|
<syntaxhighlight lang="ldpl">data:
n is number
procedure:
sub multiply
parameters:
x is number
y is number
result is number
procedure:
in result solve x * y
end sub
# call the bare sub-procedure
call multiply with 3 4 n
display n lf
# create a statement for it
create statement "multiply $ by $ in $" executing multiply
display n lf
</syntaxhighlight>
{{out}}
<pre>
12
12
</pre>
=={{header|LFE}}==
<syntaxhighlight lang="lisp">
(defun mutiply (a b)
(* a b))
</syntaxhighlight>
=={{header|Lily}}==
<
{
return a * b
}</
=={{header|Lingo}}==
<
return a * b
end</
=={{header|LiveCode}}==
LiveCode has a built-in method called multiply, so there is an extra y to avoid an error.
<
return n1 * n2
end multiplyy
put multiplyy(2,5) -- = 10</
=={{header|Logo}}==
<
output :x * :y
end</
=={{header|LSE64}}==
<
multiply. : *. # floating point</
=={{header|Lua}}==
<
return a * b
end</
=={{header|Lucid}}==
<
=={{header|M2000 Interpreter}}==
===A Module can return value===
A module can return value to stack of values. Calling a module we place parent stack to module, so we can read any value.
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Module Multiply (a, b) {
Line 1,964 ⟶ 2,422:
Call Checkit, 20, 50
Print Number=1000
</syntaxhighlight>
===A Local Function Definition===
There are two types of function, the normal and the lambda. If a Function return string then we have to use $ at the end of function name.
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
\\ functions can shange by using a newer definition
Line 2,035 ⟶ 2,493:
}
Checkit
</syntaxhighlight>
===A Lambda Function===
Lambda function is first citizen. We can push it to stack and make another reading from stack. Lambda can use closures as static variables, some of them are pointers so if we copy a lambda we just copy the pointer. Pointers are containers like pointer to array, inventory and stack. Here we define string lambda function (there is a numeric also)
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
A$=Lambda$ N$="Hello There" (x) ->{
Line 2,062 ⟶ 2,520:
B$=List$("Hello", "Rosetta", "Function")
Print B$(1)="Hello"
</syntaxhighlight>
=={{header|M4}}==
<
multiply(2,3)</
=={{header|MAD}}==
MAD supports two types of function declarations. One simply evaluates an expression:
<
Another allows multiple lines to be executed:
<
ENTRY TO MULT.
FUNCTION RETURN A * B
END OF FUNCTION</
There are several quirks here. First, the length of any identifier must not be longer than six
Line 2,093 ⟶ 2,551:
=={{header|Make}}==
In makefile, a function may be defined as a rule, with recursive make used to retrieve the returned value.
<
B=1
multiply:
@expr $(A) \* $(B)</
Invoking it
<
> 300</
Using gmake, the define syntax is used to define a new function
{{works with|gmake}}
<
B=1
Line 2,113 ⟶ 2,571:
@$(call multiply, $(A), $(B))
|gmake -f mul.mk do A=5 B=3</
=={{header|Maple}}==
<
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Line 2,122 ⟶ 2,580:
Defining a function as a transformation rule:
<
Defining a pure function:
<
=={{header|Maxima}}==
<
=={{header|MAXScript}}==
<
(
a * b
)</
=={{header|Mercury}}==
<
:- func multiply(integer, integer) = integer.
multiply(A, B) = A * B.</
=={{header|Metafont}}==
Metafont has macros, rather than functions; through those the language can be expanded. According to the kind of macro we are going to define, Metafont has different ways of doing it. The one suitable for this task is called <code>primarydef</code>.
<
<
The '''primarydef''' allows to build binary operators with the same priority as *. For a more generic macro, we can use instead
<
t := mult(2,3);
show t;
end</
=={{header|min}}==
<code>'*</code> is syntax sugar for <code>(*)</code>, which is an anonymous function that takes two numbers from the data stack, multiplies them, and leaves the result on the data stack. To give it a name, we can use the <code>:</code> sigil which is syntax sugar for <code>define</code>.
<syntaxhighlight lang
=={{header|MiniScript}}==
<
return x*y
end function
print multiply(6, 7)</
{{out}}
<pre>42</pre>
Line 2,177 ⟶ 2,635:
=={{header|Modula-2}}==
<
BEGIN
RETURN a * b
END Multiply;</
=={{header|Modula-3}}==
<
BEGIN
RETURN a * b;
END Multiply;</
=={{header|MUMPS}}==
<
QUIT A*B</
=={{header|Nanoquery}}==
<
return a * b
end</
=={{header|Neko}}==
<
a * b
}
$print(multiply(2, 3))</
'''Output:'''
Line 2,208 ⟶ 2,666:
=={{header|Nemerle}}==
<
{
def multiply(a, b) { return a * b } // this is a local function, can take advantage of type inference
return multiply(a, b)
}</
=={{header|NESL}}==
<
The NESL system responds by reporting the type it has inferred for the function:
<pre>multiply = fn : (a, a) -> a :: (a in number)</pre>
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols binary
Line 2,242 ⟶ 2,700:
product = multiplicand * multiplier
return product</
{{out}}
<pre>
Line 2,251 ⟶ 2,709:
=={{header|NewLISP}}==
<
(lambda (a b) (* a b))
> (my-multiply 2 3)
6</
=={{header|Nial}}==
Using variables
<
Using it
<
=6</
Point free form
<syntaxhighlight lang
Using it
<
=12</
Nial also allows creation of operators
<
Using it.
<
=6
|multiply 2 3
=6</
Since this is an array programming language, any parameters can be arrays too
<
=3 6
|mul [1,2] [10,20]
=10 40</
=={{header|Nim}}==
Nim has a magic variable, `result`, which can be used as a substitute for `return`. The `result` variable will be returned implicitly.
<
result = a * b</
Here is the same function but with the use of the `return` keyword.
<
return a * b</
The last statement in a function implicitly is the result value:
<
=={{header|OASYS}}==
<
return x * y
}</
=={{header|OASYS Assembler}}==
OASYS Assembler requires a prefix and suffix on names to indicate their types (an omitted suffix means a void type).
<
=={{header|Oberon-2}}==
Oberon-2 uses procedures, and has a special procedure called a "Function Procedure" used to return a value.
<
BEGIN
RETURN a * b;
END Multiply;</
=={{header|Objeck}}==
<
return a * b;
}</
=={{header|OCaml}}==
<
let float_multiply x y = x *. y</
=={{header|Octave}}==
<
r = a .* b;
endfunction</
=={{header|Oforth}}==
Line 2,327 ⟶ 2,785:
If necessary, we can create a function with name multiply, but, it will just call *
<syntaxhighlight lang
It is also possible to create a function with declared paramaters. In this case, if we define n parameters, n objects will be removed from the stack and stored into those parameters :
<
A function return value (or values) is always what remains on the stack when the function ends. There is no syntax to define explicitely what is the return value(s) of a function.
Line 2,337 ⟶ 2,795:
=={{header|Ol}}==
Function creation implemented using keyword 'lambda'. This created anonymous function can be saved into local or global variable for further use.
<
(lambda (x y)
(* x y))
</syntaxhighlight>
Ol has two fully equal definitions of global named function (second one is syntactic sugar for first one). In fact both of them is saving the created lambda in global variable.
<
(define multiply (lambda (x y) (* x y)))
(define (multiply x y) (* x y))
</syntaxhighlight>
And only one definition of local named functions (with immediate calculation). This type of definition helps to implement local recursions.
<
(let multiply ((x n) (y m))
(* x y))
Line 2,363 ⟶ 2,821:
(print (multiply 7 8))
; ==> 56
</syntaxhighlight>
=={{header|OOC}}==
<
multiply: func (a: Double, b: Double) -> Double {
a * b
}
</syntaxhighlight>
=={{header|ooRexx}}==
===Internal Procedure===
<
EXIT
multiply:
PROCEDURE
PARSE ARG x, y
RETURN x*y</
===::Routine Directive===
<
say multiply(5, 6)
::routine multiply
use arg x, y
return x *y </
===Accomodate large factors===
<
say multiply_long(123456789,987654321)
::routine multiply
Line 2,395 ⟶ 2,853:
use arg x, y
Numeric Digits (length(x)+length(y))
return x *y </
{{out}}
<pre>1.21932631E+17
Line 2,401 ⟶ 2,859:
=={{header|OpenEdge/Progress}}==
<
return a * b .
end.</
=={{header|Oz}}==
<
X * Y
end</
Or by exploiting first-class functions:
<
=={{header|PARI/GP}}==
<
or
<
Note that in both cases the <code>;</code> is part of the definition of the function, not of the function itself: it suppresses the output of the function body, but does not suppress the output of the function when called. To do that, either double the semicolon (which will suppress the output of both) or wrap in braces:
<
which will return a function which calculates but does not return the product.
=={{header|Pascal}}==
''see also: [[#Delphi|Delphi]] and [[#Free Pascal|Free Pascal]]''
<syntaxhighlight lang="pascal">function multiply(a, b: real): real;
begin
end;</
After a <tt>function</tt> has been activated, there must have be ''exactly one'' assignment to the (implicitly declared) variable bearing the same name as of the function.
Many processors do not comply with this specification, though, and allow ''overwriting'' the return value ''multiple'' times.
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
function multiply(a,b: real): real := a + b;
</syntaxhighlight>
=={{header|Perl}}==
The most basic form:
<
or simply:
<
Arguments in Perl subroutines are passed in the <code>@_</code> array, and they can be accessed directly, first one as <code>$_[0]</code>, second one as <code>$_[1]</code>, etc. When the above function is called with only one or no arguments then the missing ones have an undefined value which is converted to 0 in multiplication.
This is an example using [http://perldoc.perl.org/perlsub.html#Prototypes subroutine prototypes]:
<
{
my ($a, $b) = @_;
return $a * $b;
}</
The above subroutine can only be called with exactly two [http://perldoc.perl.org/perldata.html#Scalar-values scalar values] (two dollar signs in the signature) but those values may be not numbers or not even defined. The <code>@_</code> array is unpacked into <code>$a</code> and <code>$b</code> lexical variables, which are used later.
The arguments can be automatically unpacked into lexical variables using the experimental signatures feature (in core as of 5.20):
<
sub multiply ($x, $y) {
return $x * $y;
}</
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">multiply</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">*</span><span style="color: #000000;">b</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<!--</
=={{header|Phixmonti}}==
<syntaxhighlight lang
=={{header|PHL}}==
<
return a * b;
]</
=={{header|PHP}}==
<
{
return $a * $b;
}</
=={{header|Picat}}==
<
</syntaxhighlight>
=={{header|PicoLisp}}==
<
(* A B) )</
=={{header|Pike}}==
<
return a * b;
}</
=={{header|PL/I}}==
<
declare (a, b) float;
return (a*b);
end PRODUCT;</
=={{header|PL/SQL}}==
<
IS
v_product NUMBER;
Line 2,498 ⟶ 2,964:
v_product := p_arg1 * p_arg2;
RETURN v_product;
END;</
=={{header|Plain English}}==
The <code>Multiply a number by another number</code> routine is already defined in the noodle, so we need to tweak the wording slightly so the compiler doesn't complain about redefinition (or so the definition isn't recursive). Note that <code>the number</code> refers to the parameter <code>a number</code> and <code>the other number</code> refers to the parameter <code>another number</code>.
<
Multiply the number by the other number.</
=={{header|Pop11}}==
<
a * b
enddefine;</
=={{header|PostScript}}==
Inbuilt:
<syntaxhighlight lang
Function would be:
<
/x exch def
/y exch def
x y mul =
}def</
=={{header|PowerShell}}==
The most basic variant of function definition would be the kind which uses positional parameters and therefore doesn't need to declare much:
<
return $args[0] * $args[1]
}</
Also, the return statement can be omitted in many cases in PowerShell, since every value that "drops" out of a function can be used as a "return value":
<
$args[0] * $args[1]
}</
Furthermore, the function arguments can be stated and named explicitly:
<
return $a * $b
}</
There is also an alternative style for declaring parameters. The choice is mostly a matter of personal preference:
<
param ($a, $b)
return $a * $b
}</
And the arguments can have an explicit type:
<
return $a * $b
}</
=={{header|Processing}}==
Processing is based on Java, and thus uses a familiar C-style syntax for function definition—as it does for much else. For the sake of argument, this implementation of <tt>multiply</tt> uses single-precision floats: other numeral types are available.
<
{
return x * y;
}</
==={{header|Processing Python mode}}===
Processing Python mode is based on Jython, a fully implemented Python 2 interpreter, and thus uses familiar Python syntax for function definition-as it does for much else.
<
return x * y</
=={{header|Prolog}}==
Prolog, as a logic programming languages, does not have user-supplied functions available. It has only predicates; statements which are "true" or "false". In cases where values have to be "returned" a parameter is passed in that is unified with the result. In the following predicate the parameter "P" (for "Product") is used in this role. The following code will work in any normal Prolog environment (but not in things like Turbo Prolog or Visual Prolog or their ilk):
<
This is what it looks like in use:
<
multiply(5, 2, P),
format("The product is ~d.~n", [P]).</
This can be a little bit jarring for those used to languages with implicit return values, but it has its advantages. For example unit testing of such a predicate doesn't require special frameworks to wrap the code:
<
multiply(5, 2, 10), % this will pass
multiply(3, 4, 11). % this will not pass</
Still, the lack of user-defined functions remains an annoyance.
Prolog, however, is a remarkably malleable language and through its term re-writing capabilities the function-style approach could be emulated. The following code relies on the [http://packs.ndrix.com/function_expansion/index.html function_expansion] pack (separately installed through the packs system) for SWI-Prolog. Similar code could be made in any Prolog implementation, however.
<
user:function_expansion(multiply(A, B), P, P is A * B). % "function" definition
go :-
format("The product is ~d.~n", [multiply(5, 2)]).</
While the function '''definition''' is perhaps a bit more involved, the function '''use''' is now pretty much the same as any other language people are used to. The "magic" is accomplished by the compiler rewriting the <code>go/0</code> term into the following code:
<
A is 5*2,
format('The product is ~d.~n', [A]).</
=={{header|Python}}==
Function definition:
<
return a * b</
Lambda function definition:
<
A callable class definition allows functions and classes to use the same interface:
<
def __init__(self):
pass
Line 2,601 ⟶ 3,062:
multiply = Multiply()
print multiply(2, 4) # prints 8</
(No extra functionality is shown in ''this'' class definition).
=={{header|Q}}==
<
or
<syntaxhighlight lang
or
<syntaxhighlight lang
Using it
<
6</
=={{header|Quack}}==
You have several ways to define a function in Quack. You can do it by the classic way:
<
^ a * b
end</
Using lambda-expressions:
<
And using partial anonymous functions:<
=={{header|Quackery}}==
<
In the Quackery shell (REPL):
<pre>
Line 2,640 ⟶ 3,101:
Words don't have to be named. We could have written the above as:
<
By quoting the nest containing <code>*</code> with the <code>'</code> word, we have prevented it from being executed immediately and placed it on the data stack. Now it can be manipulated like any other nest or data stack object. We can use <code>do</code> to execute the contents of the nest.
=={{header|R}}==
<
In general:
<
a*b
# or:
# return(a*b)
}</
=={{header|Racket}}==
A simple function definition that takes 2 arguments.
<
Using an explicit <code>lambda</code> or <code>λ</code> is completely equivalent:
<
<
Note that <code>*</code> is a function value, so the following code also works (although <code>multiply</code> will now be variadic function).
<syntaxhighlight lang
=={{header|Raku}}==
(formerly Perl 6)
Without a signature:
<syntaxhighlight lang="raku"
The return is optional on the final statement, since the last expression would return its value anyway. The final semicolon in a block is also optional.
(Beware that a subroutine without an explicit signature, like this one, magically becomes variadic (rather than nullary) only if <code>@_</code> or <code>%_</code> appear in the body.) In fact, we can define the variadic version explicitly, which still works for two arguments:
<syntaxhighlight lang="raku"
With formal parameters and a return type:
<syntaxhighlight lang="raku"
Same thing:
<syntaxhighlight lang="raku"
It is possible to define a function in "lambda" notation and then bind that into a scope, in which case it works like any function:
<syntaxhighlight lang="raku"
Another way to write a lambda is with internal placeholder parameters:
<syntaxhighlight lang="raku"
(And, in fact, our original <tt>@_</tt> above is just a variadic self-declaring placeholder argument. And the famous Perl "topic", <tt>$_</tt>, is just a self-declared parameter to a unary block.)
You may also curry both built-in and user-defined operators by supplying a <tt>*</tt> (known as "whatever") in place of the argument that is <i>not</i> to be curried:
<syntaxhighlight lang="raku"
This is not terribly readable in this case due to the visual confusion between the whatever star and the multiplication operator, but Perl knows when it's expecting terms instead of infixes, so only the middle star is multiplication.
It tends to work out much better with other operators. In particular, you may
curry a cascade of methods with only the original invocant missing:
<syntaxhighlight lang="raku"
This is equivalent to:
<syntaxhighlight lang="raku"
=={{header|Raven}}==
<
a b *</
Or optional infix:
<
(a * b)</
Or skip named vars:
<syntaxhighlight lang
=={{header|REBOL}}==
REBOL actually already has a function called 'multiply', which is a native compiled function. However, since it's not protected, I can easily override it:
<
=={{header|Relation}}==
<syntaxhighlight lang="relation">
function multiply(a,b)
set result = a*b
end function
</syntaxhighlight>
=={{header|Retro}}==
<
=={{header|REXX}}==
===exactitudeness===
<
===cleaner display===
Line 2,730 ⟶ 3,184:
<br><br>I.E.: ''' 3.0 * 4.00 ''' yields the product: '''12.000'''
<br><br>This version eliminates the '''.000''' from the product.
<
=={{header|Ring}}==
<
func multiply x,y return x*y
</syntaxhighlight>
=={{header|RLaB}}==
In RLaB the functions can be built-in (compiled within RLaB, or part of the shared object library that is loaded per request of user), or user (written in RLaB script). Consider an example:
<
function
>> type(sin)
builtin</
Functions are a data class on their own, or they can be member of a list (associative array).
1. user function specified from built-in functions, here basic addition
<
{
return x + y;
Line 2,754 ⟶ 3,208:
function
>> type(f)
user</
2. function can be member of a list (associative array)
<
somelist.f = function(x, y)
{
rval = x + y;
return rval;
};</
3. user function which uses a function that is specified as a member of some list, here we use ''somelist'' from above:
<
{
global(somelist);
rval = x * somelist.f(x, 2*y);
return rval;
};</
=={{header|RPL}}==
≪ * ≫ 'MULT' STO
2 3 MULT
{{out}}
<pre>6</pre>
=={{header|Ruby}}==
<
a * b
end</
Ruby 3.0 adds endless method definition:
<syntaxhighlight lang="ruby">def multiply(a, b) = a * b</syntaxhighlight>
=={{header|Rust}}==
<
a * b
}</
=={{header|Sather}}==
<
-- we cannot have "functions" (methods) outside classes
mult(a, b:FLT):FLT is return a*b; end;
Line 2,797 ⟶ 3,251:
#OUT + mult(5.2, 3.4) + "\n";
end;
end;</
=={{header|Scala}}==
<
=={{header|Scheme}}==
<syntaxhighlight lang
Alternately,
<
(* a b))</
=={{header|Seed7}}==
<
return a * b;</
=={{header|SenseTalk}}==
<
to multiply num1, num2
return num1 * num2
end multiply
</syntaxhighlight>
{{out}}
<pre>
Line 2,825 ⟶ 3,279:
=={{header|SETL}}==
<
return a * b;
end proc;</
=={{header|Sidef}}==
<
a * b;
}</
=={{header|Simula}}==
Simula uses the term <tt>procedure</tt> for subroutines/methods whether they return a value or not. A procedure that does return a value is declared with a data type (e.g. <tt>integer procedure</tt>), whereas one that does not is declared simply as <tt>procedure</tt>. This program defines <tt>multiply</tt> as an integer procedure and illustrates its use. Note that the second argument provided to <tt>Outint</tt> gives the width of the integer to be printed.
<
INTEGER PROCEDURE multiply(x, y);
INTEGER x, y;
Line 2,844 ⟶ 3,298:
Outint(multiply(7,8), 2);
Outimage
END</
=={{header|Slate}}==
<
or using a macro:
<
The block may also be installed as a method like so:
<
or more explicitly (without sugar):
<
=={{header|Smalltalk}}==
<
mul := [ :a :b | a * b ].</
=={{header|SNOBOL4}}==
<
multiply multiply = a * b :(return)
mul_end
Line 2,866 ⟶ 3,320:
output = multiply(10.1,12.2)
output = multiply(10,12)
end</
{{out}}
123.22
Line 2,873 ⟶ 3,327:
=={{header|SNUSP}}==
For expediency, the function is adding three values, instead of multiplying two values. Another function, atoi (+48) is called before printing the result.
<
| | \=itoa=@@@+@+++++#
\=======!\==!/===?\<#
\>+<-/</
=={{header|SPARK}}==
The function definition (multiplies two standard Integer):
<
function Multiply (A, B : Integer) return Integer;
--# pre A * B in Integer; -- See note below
--# return A * B; -- Implies commutativity on Multiply arguments
end Functions;</
Note: how do you ensure then “A * B in Integer” ? Either with a proof prior to Multiply invokation or using another form of Multiply where input A and B would be restricted to a range which ensures the resulting product is always valid. Exemple :
<
type Result_Type is range 0 .. 100;</
and had a version of Multiply using these types. On the other hand, if arguments of Multiply are constants, this is provable straight away.
The Multiply's implementation:
<
function Multiply (A, B : Integer) return Integer is
begin
return A * B;
end Multiply;
end Functions;</
=={{header|SPL}}==
Single-line function definition:
<
Multi-line function definition:
<
x = a*b
<= x
.</
=={{header|SSEM}}==
Line 2,911 ⟶ 3,365:
In this example, the main routine does nothing at all beyond calling the subroutine and halting after it has returned. The values <tt>A</tt> and <tt>B</tt> are passed in the two addresses located immediately before the subroutine begins; their product is returned in the address that formerly stored <tt>A</tt>. Given that the <tt>multiply</tt> subroutine begins at address 8, the calling routine looks like this:
<
00100000000000000000000000000000 1. 4 to CI
01111111111111111111111111111111 2. -2
00000000000001110000000000000000 3. Stop
11100000000000000000000000000000 4. 7</
or in pseudocode:
<pre> load &here
Line 2,921 ⟶ 3,375:
here: halt</pre>
Implementing <tt>multiply</tt> on the SSEM requires the use of repeated negation and subtraction. For the sake of example, the values 8 and 7 are provided for <tt>A</tt> and <tt>B</tt>.
<
11100000000000000000000000000000 7. 7
11111000000001100000000000000000 8. c to 31
Line 2,946 ⟶ 3,400:
00110000000000000000000000000000 29. 12
00000000000000000000000000000000 30. 0
00000000000000000000000000000000 31. 0</
The pseudocode equivalent clarifies how the subroutine works, or how it would work on an architecture that supported <tt>load</tt> and <tt>add</tt>:
<pre>a: equals #8
Line 2,967 ⟶ 3,421:
=={{header|Standard ML}}==
<
Equivalently,
<
Using lambda syntax:
<
Curried form:
<
=={{header|Stata}}==
Line 2,980 ⟶ 3,434:
Stata's macro language does not have functions, but commands. Output is usually saved as a "stored result" (but could also be saved in a global macro variable, in a scalar or matrix, in a dataset or simply printed to the Results window). See '''[https://www.stata.com/help.cgi?program program]''' and '''[https://www.stata.com/help.cgi?return]''' in Stata documentation.
<
args a b
return sca product=`a'*`b'
Line 2,986 ⟶ 3,440:
multiply 77 13
di r(product)</
'''Output'''
Line 2,995 ⟶ 3,449:
Mata is the matrix language of Stata. Here is how to define a function
<
scalar multiply(scalar x, scalar y) {
return(x*y)
Line 3,001 ⟶ 3,455:
multiply(77,13)
end</
'''Output'''
Line 3,008 ⟶ 3,462:
=={{header|Swift}}==
<
return a * b
}</
=={{header|Symstatic}}==
You can write functions in let expressions or anonimously:
<syntaxhighlight lang="symstatic">let prod(a, b) := a*b
let prodAnon := (a, b) -> a*b
assert(prodAnon(2, 2) = ((a, b) -> a*b)(2, 2))
assert(prod(2, 2) = prodAnon(2, 2))
</syntaxhighlight>
=={{header|Tcl}}==
Strictly as described in the task:
<
return [expr {$arg1 * $arg2}]
}</
{{works with|Tcl|8.5}}
You can also create functions that work directly inside expressions. This is done by creating the command with the correct name (that is, in the ''tcl::mathfunc'' namespace):
<
return [expr {$arg1 * $arg2}]
}
Line 3,026 ⟶ 3,489:
if {multiply(6, 9) == 42} {
puts "Welcome, Citizens of Golgafrincham from the B-Ark!"
}</
=={{header|Toka}}==
<
=={{header|Transd}}==
<
=={{header|TXR}}==
Line 3,044 ⟶ 3,501:
Here is how to make a pattern function that multiplies, and call it. To multiply the numbers, we break out of the pattern language and invoke Lisp evaluation: <code>@(* a b)</code>
<
@(bind out @(* a b))
@(end)
@(multiply 3 4 result)</
<pre>$ txr -B multiply.txr
result="12"</pre>
In the embedded Lisp dialect, it is possible to write an ordinary function that returns a value:
<
(put-line `3 * 4 = @(mult 3 4)`)</
<pre>$ txr multiply.tl
3 * 4 = 12</pre>
=={{header|UNIX Shell}}==
Note that in the Unix shell, function definitions do not include any argument specifications within the parentheses. Instead arguments to functions are obtained using the positional parameters.
{{works with|Bourne Shell}}
<
# There is never anything between the parentheses after the function name
# Arguments are obtained using the positional parameters $1, and $2
Line 3,076 ⟶ 3,525:
# Call the function
multiply 3 4 # The function is invoked in statement context
echo $? # The dollarhook special variable gives the return value</
{{works with|Bash}}
return an exit code
<
return $(($1 * $2))
}
multiply 5 6
echo $?</
echo the result
<
echo -n $(($1 * $2))
}
echo $(multiply 5 6)</
=={{header|Ursa}}==
<
def mult (int a, int b)
return (* a b)
end</
=={{header|Ursala}}==
Line 3,102 ⟶ 3,551:
They may be specified by lambda abstraction, with dummy variables in double quotes, or in point-free form, or any combination. The way multiplication is defined depends on the type of numbers being multiplied. For this example, numbers in standard IEEE double precision are assumed, and the multiply function is defined in terms of the system library function, called using the syntax <code>math..mul</code>.
This is the definition in point free form,
<
this is the definition using lambda abstraction
<
and this is the definition using pattern matching.
<
=={{header|V}}==
V uses stack for input arguments and '.' is a word that takes a quote and binds the first word to the sequence of actions supplied in the quote.
<syntaxhighlight lang
Using it
<
=6</
V also allows internal bindings.
<
[a b] let
a b *].</
=={{header|
<syntaxhighlight lang="Zig">
fn multiply(a f64, b f64) f64 {
return a * b
}
fn main() {
}
</syntaxhighlight>
{{out}}
<pre>
30.0
</pre>
=={{header|Wart}}==
A straightforward way to say how calls of the form <code>(multiply a b)</code> are translated:
<
a*b</
<
=> 12</
Functions can also use keyword args.
<
=> 12</
Finally, we can give parameters better keyword args using <em>aliases</em>:
<
(* a b)</
<
=> 12</
=={{header|WebAssembly}}==
Line 3,186 ⟶ 3,616:
The following 'multiply' function will work for any type(s) that support the '*' operator.
However, it will produce a runtime error otherwise, as demonstrated by the final example.
<
System.print(multiply.call(3, 7))
System.print(multiply.call("abc", 3))
System.print(multiply.call([1], 5))
System.print(multiply.call(true, false))</
{{out}}
Line 3,217 ⟶ 3,647:
The following is Unix-style "as" assembler syntax (including GNU as). The resulting function can be called from C with <code>multiply(123,456)</code>.
<
.globl multiply
.type multiply,@function
Line 3,223 ⟶ 3,653:
movl 4(%esp), %eax
mull 8(%esp)
ret</
The <code>.type</code> directive is important for code which will go into a shared library. You can get away without it for a static link. It ensures the linker knows to dispatch calls from the mainline to the function via a PLT entry. (If omitted the code is copied at runtime into some mainline space. Without a <code>.size</code> directive only 4 bytes will be copied.)
Line 3,229 ⟶ 3,659:
===NASM===
{{works with|NASM}}
<
global _start
Line 3,252 ⟶ 3,682:
push 6
push 16
call _multiply_stack</
===MASM===
However, in MASM we do have function statements due to the preprocessor.
{{works with|MASM}}
<
mov eax, arg1
mov ebx, arg2
Line 3,263 ⟶ 3,693:
mov eax, ebx
ret
multiply endp</
Then to call it.
<
;or..
push 16
push 6
call multiply</
Return values are usually put into the register EAX. This, of course is not a must it's simply that it's somewhat of a unofficial standard. For example, C/C++ preprocessors/compilers will translate "return value" into "mov eax, value" followed by the return to caller instruction "ret".
=={{header|XBS}}==
Functions are defined by using the '''func''' keyword.
<
send a*b;
}</
=={{header|XLISP}}==
Functions can be defined using either 'classic' Lisp syntax:
<
(* x y))</
or Scheme-style syntax:
<
(* x y))</
or, if you prefer, with <tt>LAMBDA</tt>:
<
(lambda (x y) (* x y)))</
=={{header|XPL0}}==
<
int A, B; \the arguments are actually declared here, as integers
return A*B; \the default (undeclared) function type is integer
Line 3,304 ⟶ 3,727:
func real FloatMul(A, B); \floating point version
real A, B; \arguments are declared here as floating point (doubles)
return A*B;</
=={{header|XSLT}}==
Templates are the closest things XSLT has to user defined functions. They can be declared to be called by name and/or to be applied to all nodes in a matching set and given "mode". Both types of template can take named parameters with default values. Templates also have a "context" node used as the base of XPath expressions (kind of like an implied "this" of an object's method).
<
<xsl:param name="a" select="2"/>
<xsl:param name="b" select="3"/>
<xsl:value-of select="$a * $b"/>
</xsl:template></
Usage examples.
<
<xsl:with-param name="a">4</xsl:with-param>
<xsl:with-param name="b">5</xsl:with-param>
</xsl:call-template>
<xsl:call-template name="multiply"/> <-- using default parameters of 2 and 3 --></
Available in XSLT 2.0 and later versions.
<
<xsl:param name="a"/>
<xsl:param name="b"/>
<xsl:value-of select="$a * $b"/>
</xsl:function></
Usage examples.
<
<xsl:value-of select="mf:multiply(2,3)" /></
=={{header|YAMLScript}}==
<syntaxhighlight lang="yaml">
!yamlscript/v0
# Main function definition with variable arguments:
defn main(& args):
answer =:
multiply: ARGS*
say: "multiply($(ARGS.join(', '))) = $answer"
# A multi-arity function definition:
defn multiply:
(): 1
(x): x
(x y): x * y
(x y & more):
reduce multiply: multiply(x y) more
</syntaxhighlight>
=={{header|Yorick}}==
<
return x * y;
}</
Example of interactive usage:
<pre>> multiply(2, 4.5)
Line 3,342 ⟶ 3,784:
A function's return values are whatever registers or memory are changed by the function. A good programmer will explain what is returned where by using comments.
<
;returns HL = HL times A. No overflow protection.
push bc
Line 3,368 ⟶ 3,810:
pop de
pop bc
ret</
=={{header|
<
return x * y;
}
//example call
const x: i64 = 4;
const y: i64 = 23;
_ = multipy(x, y); // --> 93</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">fcn multiply(x,y){x*y}</syntaxhighlight>
<syntaxhighlight lang="zkl">fcn(x,y){x*y}(4.5,3) // --> 13.5</syntaxhighlight>
Since all functions are vararg:<syntaxhighlight lang="zkl">fcn multiply{vm.arglist.reduce('*)}
multiply(1,2,3,4,5) //--> 120</syntaxhighlight>
Operators are first class objects so:<syntaxhighlight lang="zkl">var mul=Op("*"); mul(4,5) //-->20</syntaxhighlight>
{{omit from|GUISS}}
|