Advanced Fortran Programming : 011 : Optional Parameters and Variables in module 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 protein
programming now this tutorial will be
looking at some features available in
modules and modules and functions and
even this can be up external to
subroutines also ok and we will be
looking at the option optional
parameters and the usage of safe
function in Fortran now know what I have
here is that I have written I have
written a program ok the both the
program and a module they are both
written in the same script same file so
doesn't matter even if this is written
entirely in a different file even it
doesn't matter but anyway whatever
written here is that in this module fact
ok I have a new variable called as
counter okay and I used to save comment
over here I'll explain you guys what
what's going on and then what I'm doing
is that I've written a return on
factorial function okay let me just
raise this a little lower
yeah I've returned a factor is a
function over here ok now this entire
function is in the screen okay
it's taking two variables n and C but
and NS the one which is going to be used
for doing all the factorial calculation
and all okay but the see I have declared
it as with the keyword optional okay now
and this loop takes care of all the
factorial calculation by the recursive
processes so this function is recursive
so I kept it recur I kept the keyword
over here and the function name since
I'm using the recursion over here what
I'm doing is that I'm using this result
keyword and this result parameter to
define a new variable that route which
will be returning the value okay two
different to show that this function is
this function call is different from the
result call okay and then in this
program it's exact it's a very simple
program patter and I use this this
module name
to include all the modules inside this
to include all the functions and
variables inside okay and then I'm
defining three integers n NF and I okay
and I'm setting the value counter equals
zero okay this integer which is
available in the module I'm setting it
to zero over here and then I'm getting
the value of n over here and I'm doing a
within this do loop I'm calculating the
factorial of each and every value of I
okay and I'm printing a factor love each
and every value of i from 1 to N and
then I'm printing them over here and
then finally I'm printing the total the
counter with the counter variable you
know okay enough of the walkthrough
now I'll go with a little detail which I
will give you a background of what's
going on see sometimes and for programs
you might be required to enter some
optional parameters suppose when you
guys saw in one of the previous programs
where and we use the right command okay
what happens is there's many times we
many times to print them in the silk
screen we use this operation where and
we say there isn't any there isn't then
if you know there isn't any file to look
at or unit to look at and there isn't
any farm at this rate or there we are
not using any advance advance at all
okay but but to be honest this function
is not taking only two parameters it is
taking multiple parameters inside like
unit farm at animal advance and several
others but but by default okay for using
simple processes it even if you don't
enter those values inside it will just
work out fine why it's because this it's
because this all the functions in
Fortran okay some of the inbuilt
functions and Fortran and stuff have
optional parameters meaning even if the
if those parameters were included the
process is done with a slightly
different manner but if it's not done
the process is done in a slightly the
process is done in a diff
okay so if you want if one cut if you
want that kind of thing to be included
in your programs then you need an
optional parameter over here okay and to
define enough in your into your function
or a subroutine that you are entering an
optional value inside okay
you have to use that in the definition
you have to include all the separate you
have to include all the you know all the
values in the sub in the subroutines
sorriness functional subroutine a debt
an argument list which you see over here
and then you have to define it
explicitly that certain variables are
optional using this keyword optional
okay if this is not returned then it
will throw an error if it's if it's if
it's written option even when that value
is not plugged in or when the function
is called without that value it will not
throw any error but if it does if it is
put it will just do some more functions
or more values depending on the
depending on the value okay
and now let me now ignore about this
counter for a second counter for a
second and even ignore about this
counter for a second now let me ask you
guys expressionist how to work how this
works now ignore this counter variable
over here now I'll walk you guys through
define n over here within turned in and
define C with C being an option variable
I did that define it with intent in
nothing more and even if this is yeah
that's okay that's okay
not a big deal no ignore this counter
thing now if this is just the usual fact
except for this part and this part this
program is just the same recursive
factorial function which right which I
explained to you guys in the basic
photon program tutorial it's just the
same thing okay if the N is less than
one this if somehow a less than or equal
to 1 then the function will then the
function will def F 1 means the
factorial to be 1 whereas if it is
greater than or equal than one it's
going to call itself again with a
slightly reduced
and then when that result comes out it
will multiply that result with the end
and goes on with it so even if you enter
Phi you will go to four and then that
will call three that will call two that
will call one and when it calls one it
returns one so when that comes one x two
will run here then then two that two x
three will return three multiply before
I mean two x three six six mil to
belabor for like that and so on and so
forth it you just call its up again and
again and again and that's the job okay
now this is how it happens now note it
that only when this optional value is
given this well this part of the
statement works now I will explain this
okay this is when the function is called
with all the optional parameters now if
you guys notice in this do loop I am
calling this function fact without the
do loop without it up optional parameter
so if I were to compile this it works
fine well this it works fine if I were
to execute this okay it's asking me for
a value so let me give say pipe fine
if I give fight water it's showing me
that the value of one factor Lillis one
value of two factorial is 2 3 PI over
six four factorial is 24 five factorial
is 120 and so on and so forth
ignore this statement this is working or
the counter thing but it doesn't matter
okay
so it works out fine okay so if you guys
notice if then since this is done
without the optional argument it just
works fine but now they were to push put
optional argument like say one any value
for that for that any value for that
matter as long as it's an integer
because I define this optional parameter
to be an integer so this has to be the
value that you pass over here is should
be an integer but any value
okay now since I pass it in they pass it
now to know whether a function value is
present enough file or not whether that
value has been input K plugged in or not
there's this inbuilt inferencing
function called as present now what this
what this will do is that it will give a
logical output as to as to true as like
a true
now if this tongue if this value is if
the C value is actually and plugged into
the function
okay now this pleasant function return
true okay if it's not plugged in it will
return false so this way you can use an
if statement to do addition making kind
of stuff to do it now since in this
process see if this event we have an
integer plug then this one will be
stored and C 1 will be stored and C and
then this job since this is present
we're here in this program that is
present now what we'll do is that this
if statement becomes true and it will
print the value of N in this current
recursion okay and now even here is the
value of n as present if this bad if
this press C is present okay
this if statement becomes true so this
statement will be will be printed and if
this is false and you see it's not
present this goes away now let me give
let's just give you guys a comparison
I'm not printing I'm not printing the
value here so if I were to compile build
and execute this let me give a value for
enter it works fine now I have it here
and I know what I do is that I just give
it one something nothing about to
compile this build this and execute this
again okay now let me give this to be
Phi oh sorry
hold on okay fine now if I were to
compile this build this and execute this
now Phi it works sorry no it works now
what it does is that because this
present values put in and since its
present it just prints this statement
all over it just prints this and value
is ten values and all and this way you
get an idea as to how this function is
working on
now if you guys you notice this way
you'll get you're clearly getting an eye
indication that you have your recursion
is going on here okay then when the
value is one okay the you're now you're
now you're and you have much you have a
better proof that this else statement of
this if it's not work this is not
executed it's rather work or going here
and it's getting returned and you get a
feel that now you're getting a proper
feel that how this function is working
now any when then when I is to okay and
I believes too it goes over here and
prints the value to and then and then
the recursion gets called and goes over
here
when it goes over here it prints N
equals one and returns one and that goes
back and so on so far in factorial 3 for
three factorial is equal to 3 to 1 okay
because of recursion it just goes in the
descending order from then it returns
back from then it returns back and then
that's it like that so if you guys
notice sometimes using optional
parameters will be very useful for
debugging and checking whether your
program is working nice or right right
or wrong okay and that's one of the
features now the other than that when
you use
optional parameters you can use this for
you know performing little additional
calculations or additional job or
addition some other debugging stuff
which you might have to work work it out
some additional default values okay if
certain values are not plugged in
properly you can use them you can use
them with certain conditions and all and
proceed with it also know that mean look
let me counter the last topic in this
video last topic in this video the save
function now suppose if we want to
access some variables inside I'm in a
primary know module in the function
there is a space facility available now
what about what was it saying yeah
variables inside of module all this time
we were looking at the modules which
have only functions inside it but there
is
feature of saving variables also now if
I were to okay now server to uncomment
this out okay and run this you know
it'll work fine it'll work fine okay but
there is this thing okay I'll explain
now if you use any variables inside if
you use any variables inside of module
that malfunction that variable becomes
accessible to all the functions and
subroutines defined within the module
and whenever you use a module okay
whenever you whenever you use a module
like inside another program all the
contents all the contents including the
variables and functions all of them get
used by the function directly all of
them get used by the program also
directly okay that's why okay ignore the
save part for a moment that's why when I
included this integer counter integer
count integer counter okay
I'm using this counter variable here
without even defining it inside the
function alright
that's because this is inter this
counter is int this count
this function is internal to the module
so this counter becomes kind of global
kind of global to the function okay and
since I'm using this module inside this
program okay
not only this function even this counter
variable becomes a part of it comes
included to the program okay
this way you can access counter now what
I'm doing what I'm doing in the counter
variable is that whenever the I'm
setting in the function they said in the
program I am setting the initial value
of the counter to be zero okay setting
initial value of the caller to be zero
and now what i'm doing here is the
vendor is that okay I am just increment
incrementing the value of the counter to
be one whenever a function is called
so whenever the factorial function is
called either by recursion or by direct
cough unction call it doesn't matter as
long as the program is running the
counter value gets incremented
regardless of which call switch
okay it doesn't matter the weather the
function calls it itself recursively or
whether some other function calls it or
whether doesn't matter even if the
program calls it again and again doesn't
matter the counter uh variable just
increments every increment by one unit
every time the function gets called okay
and that value is kept in a global
memory and kept in a global memory kind
of and then it's get printed over here
so I forgot to run compile build and run
this okay in effect you have to click
fie okay
this n value is n value is 1/2 irregular
and all these are because we entered
this optional parameter and if you guys
notice at the bottom okay
this factor the function is called 15
times in total if you guys want to count
it out it gets called five times okay
once through through the program and the
remaining four through recursion okay so
it gets called five five times for the
five factorial three four times for the
for fighter the three times for three
factorial 2 x over two five ten one time
for y only once for the zero factorial
sorry for the one factorial so
ultimately this program gets called by
it's called I mean this function gets
called 15 times in the total execution
so you're getting a result so you're
getting a result the counter are you
getting current wrestle count result
with counted equals 15 and that is
getting printed at the bottom okay this
way if you have certain functions in a
program you can use it some certain
variables in a program or a module you
can use it and I'll explain one more
stuff one more topic over here the save
function the save command now what does
this save command S is that it this
makes the command I mean this makes the
variable this makes the variables
defined within the function are within
the variable within the function or an
atom or a module or a program completely
global meaning
suppose if I were to write a new
function okay a new function or new
variable and if you want to pass this
value to there and something of that
sort
okay this save function will be used
okay it kind it kind of makes it every
all the job completely completely global
meaning this counter because when as I
put it in save okay even if I wanted to
access this counter value and some other
function or some other progress some
other module in some some other function
in some other module this counter can be
accessed because I put this in safe
similarly if I write some other value
over here and they use the save command
that set of value or values can be you
know made accessible to all the programs
also okay well that's all I have for you
guys in this tutorial here maybe in the
next tutorial I'll explain you guys
about the safe function a little more in
detail okay with a little more detail
and with that we'll be jumping with that
concept in mind we'll be jumping into a
few more things regarding they got
regarding functions and subroutines
regarding from regarding functions and
subroutines okay that's all I have for
you guys in this tutorial thank you guys
for watching and I'll see you guys next
tutorial bye