91 lines
2.7 KiB
Julia
91 lines
2.7 KiB
Julia
# Calling a function that requires no arguments:
|
|
f() = print("Hello world!")
|
|
f()
|
|
|
|
|
|
# Calling a function with a fixed number of arguments:
|
|
function f(x, y, z)
|
|
x*y - z^2
|
|
end
|
|
|
|
f(3, 4, 2)
|
|
|
|
|
|
# Calling a function with optional arguments:
|
|
# Note Julia uses multiple dispatch based on argument number and type, so
|
|
# f() is always different from f(x) unless default arguments are used, as in:
|
|
|
|
pimultiple(mult=1.0) = pi * mult # so pimultiple() defaults to pi * (1.0) or pi
|
|
|
|
|
|
# Calling a function with a variable number of arguments:
|
|
|
|
f(a,b,x...) = reduce(+, 0, x) - a - b
|
|
|
|
|
|
# here a and b are single arguments, but x is a tuple of x plus whatever follows x, so:
|
|
a = b = c = d = e = 3
|
|
f(a,b,c) # x within the function is (c) so == 0 + c - a - b
|
|
f(a,b,c,d,e) # x is a tuple == (c,d,e) so == (0 + c + d + e) - a - b
|
|
f(a,b) # x is () so == 0 - a - b
|
|
|
|
|
|
# Calling a function with named arguments:
|
|
# Functions with keyword arguments are defined using a semicolon in the function signature,
|
|
# as in
|
|
# function plot(x, y; style="solid", width=1, color="black")
|
|
#
|
|
# When the function is called, the semicolon is optional, so plot here can be
|
|
# either called with plot(x, y, width=2) or less commonly as plot(x, y; width=2).
|
|
|
|
|
|
# Using a function in statement context:
|
|
# Any function can be used as a variable by its name.
|
|
|
|
circlearea(x) = x^2 * pi
|
|
map(circlearea, [r1, r2, r3, r4])
|
|
|
|
|
|
# Using a function in first-class context within an expression:
|
|
cylindervolume = circlearea(r) * h
|
|
|
|
|
|
# Obtaining the return value of a function:
|
|
radius = 2.5
|
|
area = circlearea(2.5)
|
|
|
|
|
|
# Distinguishing built-in functions and user-defined functions:
|
|
# Julia does not attempt to distinguish these in any special way,
|
|
# but at the REPL command line there is ? help available for builtin
|
|
# functions that would not generally be available for the user-defined ones.
|
|
|
|
|
|
# Distinguishing subroutines and functions:
|
|
# All subroutines are called functions in Julia, regardless of whether they return values.
|
|
|
|
|
|
# Stating whether arguments are passed by value or by reference:
|
|
# As in Python, all arguments are passed by pointer reference, but assignment to a passed argument
|
|
# only changes the variable within the function. Assignment to the values referenced by the argument
|
|
## DOES however change those values. For instance:
|
|
|
|
a = 3
|
|
b = [3]
|
|
c = [3]
|
|
|
|
function f(x, y)
|
|
a = 0
|
|
b[1] = 0
|
|
c = [0]
|
|
end # a and c are now unchanged but b = [0]
|
|
|
|
|
|
# Is partial application possible and how:
|
|
# In Julia, there are many different ways to compose functions. In particular,
|
|
# Julia has an "arrow" operator -> that may be used to curry other functions.
|
|
|
|
f(a, b) = a^2 + a + b
|
|
v = [4, 6, 8]
|
|
map(x -> f(x, 10), v) # v = [30, 52, 82]
|