Passing function arguments to VoronoiGeometry and VoronoiFVProblem
The FunctionComposer
is internally used to glue together real valued functions. Therefore, if a user wants to glue together functions and afterwards work with "glued" information generated from HighVoronoi
, using FunctionComposer
is the way unify internal and external calculations.
The FunctionComposer struct
The FunctionComposer
is the element implemented in HighVoronoi
to concatenate several Float
or Vector{Float}
valued functions into one single Vector{Float}
-valued function using vcat(...)
. It is built using a call of the following method.
HighVoronoi.FunctionComposer
— MethodFunctionComposer(;reference_argument, super_type, _functions...)
The composer takes the following arguments:
_functions
: This is a list of named funcions.super_type
: suppose your functions return values of typeT
andVector{T}
you should setsuper_type=T
reference_argument
: Your functions take values of typeFloat
and are well defined in0.0
? Then you can put e.g.0.0
here. If your function acceptsStaticArray{3,Float64}
put e.g.SVector{3,Float64}([0.0,1.2,3.4])
A typical example would be
f = FunctionComposer(reference_argument = [0.0,0.0,0.0], super_type = Float64, alpha = x->norm(x)*x, beta = x->sum(abs,x) )
or:
myfunctions=(alpha = x->norm(x)*x, beta = x->sum(abs,x))
f = FunctionComposer(reference_argument = [0.0,0.0,0.0], super_type = Float64; myfunctions... )
The latter has the advantage that you can define your set of functions once and for all and use it again and again ensuring you always have the same order in the arguments. This brings us to an important point:
FunctionComposer takes the order of functions as given in the argument. That is if you make function calls
f1 = FunctionComposer(reference_argument = [0.0,0.0,0.0], super_type = Float64, alpha = exp, beta = sin )
f2 = FunctionComposer(reference_argument = [0.0,0.0,0.0], super_type = Float64; beta = sin, alpha = exp )
the algorithm will create two different functions x->[exp(x),sin(x)]
and x->[sin(x),exp(x)]
and it will NOT be able to clear up the mess this creates....
Retrieving the full (combined) function
The full function is stored in the variable FunctionComposer.functions
.
myfunctions=(alpha = x->norm(x)*x, beta = x->sum(abs,x))
f = FunctionComposer(reference_argument = [0.0,0.0,0.0], super_type = Float64; myfunctions... )
myvalue = f.functions([1.2,3.4,5.6])
Decomposing the Composer
To retrieve single information from an array like myvalue
in the last example, you can simply use the internal function HighVoronoi.decompose(...)
:
myfunctions=(alpha = x->norm(x)*x, beta = x->sum(abs,x))
f = FunctionComposer(reference_argument = [0.0,0.0,0.0], super_type = Float64; myfunctions... )
myvalue = f.functions([1.2,3.4,5.6])
values = HighVoronoi.decompose(f, myvalue)
println(values[:alpha], values[:beta])
If you whish $1d$-vectors to be returned as scalars, try out this one:
values2 = HighVoronoi.decompose(f, myvalue, scalar=true)
println(values2[:alpha], values2[:beta])