Advanced Fortran Programming : 020 : Functions as Dummy Arguments Video Lecture | Introduction to Fortran Programming (AdvancedLevel) - Database Management

hello guys my name is Aaron and welcome
to my channel this series is a series of
tutorials on advanced Fortran
programming now in this tutorial we'll
be seeing how an example of how to pass
functions and subroutines insight into
other functions and subroutines as dummy
arguments okay sounds I suppose I'm
sounding clear okay okay before we go to
that I like I just have a small program
over here and we'll walk I'll walk you
guys through as I explain the concept of
now in the one of the previous programs
we saw how to pass the very how to pass
variables into a function or a
subroutine mostly function a function
and use the function as a dummy where
and use the function such a manner that
the variables become dummy all right now
there is this feature in Fortran wherein
you can pass very functions as dummy
arguments inside them okay and when you
pass the any pass them you can you can
you know use them and several master
whichever way you want use them in
whichever way mean you want with a
different name okay now before before
they go to the before I go to that next
one a little more deeply okay I'll walk
you guys through the program so you guys
understand I have two variables N and
I've said to be six and four I have two
integers per and calm of kind integer
eight it is a rate I have an integer of
kind eight and x2 and it I mean it's an
external function fact okay and I have
this and commented this out and I have
an external function called the sign
si in e I set X to be zero I have two
values y1 and y2 and I said and I define
okay the intrinsic function cost with
this keyword intrinsic okay now this
will be used for passing the function as
an our dummy argument function as a
dummy argument into another function
over here
okay now why on the sine of X no
question no bruh no I mean it's not a
big it's a simple now y2 will be sine as
I ate okay you know inside that function
you're passing X and you're passing cost
into it now the thing is what are you
doing here is that you're doing the COS
function the intrinsic ask function as
an argument into the into the into this
function sine si Yi okay and what I'm do
okay now this this is so far okay and
this is the fat function that's okay
okay that's fine but let's have a look
at the sine function first of all let's
say any function first of all now you
guys look at this this is the sine
function it's fairly straightforward now
what I have here is that I get the value
of x with an intern in and it's real
okay
and I said the function which I'm
getting over here with the keyword
external I'm not using intent our intent
of intern keywords like interned in or
interning out or in turned out over here
I'm just using this cave or external
over here now I'm just printing the
value of x run it as it enters in just
to see whether the values are fine same
or not and then I'm using sign as the
Miss ascetic sign as the func as the
function valuable function of F okay so
it's a function I'm using the function
like directly with the value X all right
with with the past value X simple enough
okay now if you guys noticed the into if
you guys notice the engine immunity of
this function is that this F need this F
can have any definition it can be the
sine function it can be intrinsic
function or a an extrinsic function like
this itself okay but because of this
kind of a definition okay you can
literally pass any function into another
into this function but it should return
only one value but you can pass any
function into this one function and as
long as it takes a single argument into
it all right now
that's the speciality of this and
because of this picture over here F is 3
f is treated as and the argument over
here now you can change the nature of
the nature
function f depending on your condition
or need okay and when even when you
change any of them okay you don't have
to modify this function say I say any
function at all that's advantageous
blocking dummy arguments and and right
now this function sign I say any
actually passes the cost from the
intrinsic function cars are in it okay
you might ask me why should I pass a car
intrinsic function into another function
okay well suppose you were suppose you
if you have a need let's say okay I
cannot think of think of think of you
know a need where you need where and you
have to pass an intrinsic function it is
already available in to any library or
any function and Fortran or any
subroutine in Fortran I don't think of
any example where and you can you need
to pass this an external argument but
just a thought okay I just this is more
of an information kind of a thing
suppose if you want the passing and cost
function like this yeah but I do have a
need suppose if you want to check if you
want to you want to pass any kind of
function into it into it into another
function like this you may have to check
it with sine function or cosine function
Iranian built functions also okay
suppose if you're building a let's say a
new algorithm or something to find the
square root of the square root of a
value or a you know the cosine of a
value let's say and if you want to
compare this with your algorithm and
your algorithm and the already pre-built
inbuilt algorithm this useful you
finding the cost function okay in those
kind of cases if you want to compare
them in the same function or something
of that sort something of that sort then
you may have to pass this intrinsic cost
function into the other cost function
okay now suppose if the sine function
inside the sine function you define it
in such a manner that it calculates this
it calculates the cosine function cosine
function using a new algorithm and you
want to compare how accurate this
functions calculation of sine and this
functions calculation is this inter in
this one I mean this function
calculation of cosine function value and
this functions inbuilt functions
calculation of cosine value let's say
they want to be the same or not okay
same or not then it's not scare some
cases you may have to pass an intrinsic
functions as an external argument kind
of a thing
it's just an example that can that came
to the top of my mind so nothing much
okay suppose if the thing is if I write
2 pi if suppose if we do not include
this interesting function okay and I
pass this cost function just like that
if I were to compile this I will get an
error over here
I will positively get an error over here
okay okay and now I possibly can
positively get an error over here
okay so what I have to do is they'd if I
were to if I had to pass if ever
if I have any time is a compulsion to
pass compulsion to pass
intrinsic function into into another
function or a subroutine
then I must definitely declare it
intrinsic okay now let's look at this
per come subroutine over here okay for
that I use this function function this
dummy function fact which fact for
calculating the factorial what I do is
that I just pass the end as a dummy
argument over here I define fact as 1
okay if the end is less than or equal to
0 I said fact to be one fair enough
simple enough but the fact is then if n
is not equal to 0 and it's hopefully
it's greater than 1 or if we gave
hopefully it's 1 or greater than 1 okay
then okay let me set this less than or
equal to 1 okay this this will work fine
if it's less than or equal to 1 its fact
one if it's if it's you know if it's
great if it's 2 or 2 or 2 or above
okay this do look at this do loop will
run till the till n times and calculate
the value and send it off ok and this
factor will function ok will is used and
the subroutine over here okay I'm
getting two values n comma are getting a
to out values appear power compare and
come and I'm defining this subroutine in
the subroutine defying this factory
function as external external now I'm
using the family using the function like
using the function to calculate the
fermentation using this general formula
and constants combination is actually
permutation divided by FN r factorial
I'm just using that instead of
calculating this again reducing that
simple as simple as that
no now if you guys look at the ingenuity
of the generality of this program it
reusability of this program because
because I defined a factor B external
over here okay and I'm passing this
factor B over here
ok I don't I can pass any function into
it ok I can pass any function into it it
will not be the fat function it can be
any function ok ok I can pass any
function into this / calm / calm as a
dummy part come okay because of this
kind of argument definition I can I have
given over here now with this being said
because of this you can use this sub u
sub routine for do to do me any kind of
job any kind of job as long as the root
the order and this function is more or
less a fungus ability and smaller as the
same I think you guys I think you guys
get the job okay
suppose if ever is this fat this instead
of factorial if I just say that this is
like n divided by n minus R okay this
fact just returns the same value and
just return the same value let's say
okay then this can then it's a fact
imprisons in itself in fact in fact n
minus R times n minus R itself then this
will be ended with this permutation will
permutation value will be n divided by n
minus R and this will be / / / R
simple as that you can use any function
under under the under the hood if you
pass factor if you passed this function
as an external thing over here okay and
to show you guys this fact to show you
guys this is different okay
okay to come if I were to compile this
will throw an error stating that setting
that
a fact one has no implicit type okay
even if I define fact one over here
not one over here the compiled this I
still get another okay and then I have
to set everything to be fact one fact
one over here in order to compile this
that part that part that does not have
any issue but it's okay they remain
there are some parts in the there is a
problem on the part of but there is no
issue over here okay and one more thing
and one more thing and one more thing
okay suppose if you had to use a certain
function intrinsic okay okay let me
compile this okay no issue no I should
just just a warning but okay nothing to
worry suppose if I were to ignore this
fact external keyboard over here if I
just include this into into just integer
fact like this if I were to compare this
with this and run this I get a say I get
a segment segment fault error okay
just getting a segmentation fault error
because this function is kind of working
like a dummy argument they use this vein
as a dummy argument so it's kind of
having some internal issues which kind
of break it break the executable so it's
the executor becomes crashed okay for
this function if this functional is
necessary to put the external argument
for the function like this even if sine
is not defined as external and if I were
to run and build and execute this it'll
just it okay hold on I think let me run
this properly and this properly
okay they should not be two of them over
here sorry you ever to run this compiled
and run this okay it now it's working
fine okay
now if I were to if I were to remove
this up and include this over here that
on compiled and run this it'll still
work fine okay so it will work fine so
what do you notice is that sometimes for
functions even if you don't include the
external parameter they'll work for
nicely but it to our but for this
function if you try if when we try the
same it throw up throw up a warning so
based on the kind of based on the nature
of the function it is better than it's
based on the kind of each of the
function you can you can skip this
external keyword if the functions are
outside of program but in general
practice it is recommended to put
external external keyword if the
functions are outside the program or
whether inside the program regardless of
the nature just as a caution just as a
precautionary check okay and now one
more thing is that okay one more thing
is that if I were to include this sine
function as an intrinsic and I'm already
using the sine function over here you
will get some problem we will get some
problem watch okay okay if I'm using the
I'm setting this intrinsic find to be
the intrinsic fraction I'm using sine
over here and inserting the sine
function over here using this si any
function and a passing sign itself as
the argument over here okay if ever to
you know they might there might be some
errors over here issues over here I
logic I'll tell you guys how this
happens okay and okay now let me just
seven seven seven just give you this an
executable issue three you look at the
power
never takes you at this alright execute
this this looks this looks fine okay
some sometimes this looks fine
but what happens is that sometimes you
might get another okay sometimes you
might get an L sometimes you might get
another or a code crash or something of
that sort
okay call clash is something of that
sort that executes this again it works
fine
okay now if I were to change this value
to you know five and three okay you
never to compile if ever if ever to no
run this okay it's all running fine but
sometimes what happens is that if you do
not do that if the generating variables
are different or something of that sort
me here if the values if you change the
values or something and they've still
ran it for this kind of a case we are
using a function okay this kind of okay
let me see I just made this okay it
looks fine I had to come to do this it
looks fine okay really do
okay not bad but okay me were to set
this to one let's say I'm just
experimenting things over here but this
okay it is getting changed okay
sometimes in some versions are for
aspersions or Fortran it is not required
to you know said if you are using the
function already you don't have to
define this intrinsically like this but
is that if I were to do the same with
cos okay
compile this I get another okay since
I've used sign here already if I were to
compare this this doesn't show me an
error because even when these are
commented out so this is a kind of an
observation yet to keep in mind and this
may be useful this can be useful
depending on your application well
that's all I have for you guys in this
tutorial hope I didn't bore you guys
with lot of D worry guys with this
examples this is kind of thing that you
have to keep in mind when you're when
you have an sn2 pass other fun when
intrinsic and other other functions into
another more functions or subroutines
okay thank you guys for watching and see
you guys next time bye