Advanced Fortran Programming : 013 : Pure Functions and Subroutines 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 photon programming
now in today's program so in today's
like in this lecture we'll be looking at
some one important concept colors the
pure procedure concept or else pure
function or pure subroutines concept now
what does that mean I'll give you guys
an explain I will give you guys a quick
in quick explanation see we all saw in
the in all the functions and subroutines
that we use so far that functions can
functions in subroutines you know they
can use they can do print statements
okay they can in get values and input
print values yes they can do a lot of
input operations output operations at
all and they can if you want you can
make lot of changes to the global
variables within some modules & sub
great weather modules also yes now what
does a pure funk subroutine does is that
this up this this sub protein has a lot
of constraints and restrictions to it
now the why certain considerations
because if these constraints are put
into it okay then the sample teen are
the function becomes more easy-to-handle
wear my rain was easy to handle and it
gives a lot of optimizations while
running the while running the running
the function of subroutine okay now how
to do that is simple already do is just
write a small write the keyword pure in
front of it okay now I'll there I'll you
may not be understanding how rotten
Daleks going on over here okay I'll walk
you guys through i'm using the same
factorial function over here sorry guys
you might be guys might be thinking why
is this guy just using factory long time
for all this expose our explanations for
the past three lectures and all okay but
it's easy factorial functions are you
know very easy because you know it does
a lot of operations and it's easy to its
kind of easy to operate and it
makes it's also useful because you know
if you want to have a return the fan aha
you won't have a different return name
variable and instead of the actual
function Amanda it makes a lot of sense
that's why okay what I did here is that
i've defined parameter n parameter value
n which is equal to 10 you can set it to
20 also and then I mean it define an
integer of kind eight of I value I and
then I said to die 21 DRS have dimension
10 since n equals 10 okay namely num and
num fax num will have as in the set of
numbers from 1 to N and none facts will
have a factorial of these numbers
correspondingly and then i'm using this
external external keyword to do not do
it were to indicate to the program that
will be using an external function
external function call us pat underscore
num okay here using assam using a
simplified using a simplified one line
declare a one-line assignment okay using
some array operation features and all I
setting all the values of num2 from val
use of numb from base equal to their
indices so why so this num matrix from
which ranges from one number i from
which ranges from 1 to n is set to one
to n accordingly using this using this
I've Arab using this I variable
similarly what i'm doing here is that
i'm setting the num facts from 1 to n
equal to the factorial of the factorial
of the number in the factorial of the
number with index from the numb from the
num matrix of a memory over here with
index I so this will return this will
this will return the fact 1 factorial 2
factorial 3 factorial so on up to n
factorial and all the value all these n
values will be allocated accordingly
accordingly based on the index in the
num facts matrix ok the guys from a big
I saw this in one of the previous
tutorials in are doing the basic
tutorials basic photon program tutorials
have a look at that and what I am doing
is they're introducing into loop to
print the mattresses here they each and
every matrix here okay and in here i am
using a pure factorial function okay to
do all the job what i am doing is that i
am setting and getting the value now the
number here asserting an integer I and
then setting fact to be one okay the
function is FAC underscore now but it's
going to get going to return a value
return an entirely different result
which result with the variables fact
okay it's going to return a is going to
return that with fact simple as simple
as that okay because this will be using
again and again and again and so so on
so forth okay now or else what you can
do is just you know an alternate
procedure which ever you can what you
can do is that you can do like this you
can write fact here and so I'm going to
ski without faq num equals fact if I do
this the second works fine but there is
a there is a thing if I had to you know
comment this out then have to come if
ever two no comment this comment this
part of the family function out if you
have to write this as i can to scorn um
okay none you had to run this this would
throw me some lot of error because faq
underscored anomalous and defined kind
of stuff and if you cannot use the same
function variable itself to do the same
job and also it's kind of messy so what
so the better thing to do is that is
that saved in a separate variable
thereby yeah okay dad by your job is
simplified the simplified much ok this
is this this will do okay well okay fine
now well how does this pure function
different from other other functions
no watch now here allow a run this
program ok compiled builders Buddhist
and execute this ok sorry it prints it
prints that were one factor illest 12
pattern is to approve like that and so
on up to the 10 factorial is still fine
suppose suppose if I were to type this
has 20 ok compaq sorry the compile and
execute compiled will then execute yeah
nice yeah perfect it brings all the
values up to 20 factorial nicely ok let
this 20 be there now what I do is that
suppose if ever to use a print statement
inside this and compile this it'll throw
me in error stating that print statement
is not allowed with turn up your
procedure ok now so so when I comment
this out but when I compile this again
it works fine now this is one of the
restrictions and pure functions pure
functions and pure subroutines let me
let me list them all here let me list
them all here ok there are a few things
first rules for pure functions and pure
sub routines ok first first rule is
first rule is that all all optional /
dummy arguments arguments must must be
of type
intent in okay so this is what this is
one rule second second what happens is
what happens is that what it shows is
that all intent in variables should not
be sorry the accident Lee modified some
most most of the time even when the
value is modified something it was
thrown it one throw an error but watch
suppose if ever two right suppose if
ever two right here num equals num plus
one and then right num equals num- one
essentially the essential even after
modification it works fine but it will
just throw an error stating that is a
throwing error stating that you know the
damn imma because it may give it as in
turn in you cannot modify it just cannot
modify it okay and but if it's a pure
function is a pure function again it
cannot modify it okay no sound but the
sample some compilers I think it will
just show these as warnings but it will
not make the modification but anyway but
anyway the intent in variable should not
be accidentally modified at any chance
and no save attribute that's the third
rule no safe attribute none of the
variables should have a save attribute
with them okay this is another rest
another restriction okay if you're using
save attribute then this function can
you cannot use the pure attribute to it
so this is something important okay and
this order even initialization
and the these very this these functions
ok no sir save attribute this up no save
attribute inside the inside the function
or subroutine ok and next rule is that
the subroutine function should not
handle handle global variables global
variables is in the function our sub
union should not have the global
variables and say save variables ok this
is another condition this is another
condition you have to keep in mind the
subroutine a function that we're using
should not handle global variables and
say that say variables okay and the next
condition boy I know there's lot of kind
I know there is like I don't know there
is a clot of conditions over here and
then and then let's see if I can
remember if i can remember properly if
this procedure this procedure should
call only pure procedures meaning
meaning here what I mean by procedure is
it is the same just a just a note
procedure applies to functions or
subroutines
because it is a set of the set of
instructions or a procedure that you
have to do that's what you're doing in a
functional subroutine so so if you are
using if you're using a pure function or
a pure separating it can call only other
pure functions are others are separating
so if you have a recursive subroutine as
equals a function okay and if you want
to call itself then if you want to call
if you want if you are defined it as too
pure you know you can't do it and if
you're using a pure function okay and it
can call only other functions which are
pure you cannot call even if you don't
define it as pure that's okay but it
might work or work its way around but if
you're using a pure keyword then is but
if you are but if any other book
conditions are not followed then then
you cannot call those functions or
subroutines inside and probably the last
the last and the most important and by
most important rule is that no input and
output operations operations inside
inside procedures okay now if you don't
do not include any inputs and output
operations like print statement or
reading statements or write functions
and Oliver if you're not including any
of these just intend in in turned out
stuff nothing more nothing less then
nothing more nothing less then you can
assign that function or a subroutine to
be a pure value okay now with these
conditions into picture now it works
fine now if I were to write pure now for
this function pure applies because first
rule all optional dummy against must be
of intent in okay since there aren't any
optional arguments or something so this
that's not hold good but so you don't
need so this is not to be worried about
okay second all
in 10 in variables should not be
accidentally modified now this is the
only intern variable here and we're not
modifying it anywhere so no problem okay
now no save the attribute inside this
function subroutine ok now let's you
just poke around and say save I ok if i
run compile this it shows an error
saving the save attribute at one cannot
be specified in a pure procedure ok so
this very clearly say that you cannot
have a save function save variable
inside of your function but if it's not
pure yes same you can change I no
problem next the function subroutine
should not handle global variables and
save variables ok that it since not
handling any any of that stuff so it's
ok this function is not handling such ok
no problem and then this procedure
should call only other pure procedures
well as far as this goes by it doesn't
but but anyway it's not as it doesn't
matter and finally no input output
operations inside procedures and in this
i'm using this print operation print
function to do a print function to do an
output operation whereas this display
operation ok if i were to compare this
it throws me a new error stating that
print statement not allowed and not
allowed in that ok let me get an input
operation read come num ok I save this
it's an input up into the input output
are your operation and it's not allowed
ok and finally one more stuff right come
a star num ok even this is not allowed
so these things are not allowed ok so
suppose if we have a red function or
something or write function or print
statement or any of these input output
operations you cannot use inside if you
are using these in a
function or subroutine then you cannot
make it pure but if these are not
available it's better to use pure
because okay why indie because these
functions can be these functions when
you use a print statement read statement
or write statement okay what happens is
that when you use input operation to
save a tribute right attribute on our
global variables and other stuff and the
Compellent has to make make a lot of
relaxations on the function x in terms
of memory in terms of stack size in
terms of you know in terms of n of
optimization and also it has to allow a
lot of the desk does it count it has to
allow lot of you know an optimized works
in the machine code either running at
the background to make a la make
adjustments to print the data read the
didn't write the data and you know all
the saving the variables and all okay
these has to be done kind of
unofficially or something when the
function is not made pure okay but then
a pure function when the function does
not do any of the above-mentioned jobs
okay me which if it obvious all the six
rules is mentioned up on the top on this
stuff then this function this function
can be optimized this function as a
protein can be optimized nicely okay it
doesn't matter if it's an error occurs a
function that doesn't matter but it can
be done nicely okay so it so no problem
if we were to use pure function though
it the function can be optimized very
very nicely so that you know it becomes
it runs much faster it kind of runs much
faster and gives you little more results
at least maybe for this kind of a
function this kind of a program this you
might not notice a big change but maybe
in a baby in a long-term process baron
you're working with a very complicated
function and stuff this will work nicely
now further to compile this it works
nice builders and execute this perfect
what do you have here is AB entirely
pure subroutine
okay and this is can't this say a pure
function and this keyword pure can be
used to functions also but this is used
to subroutines also but in a similar
manner that's all well that's all I fi
guys in this tutorial and one more thing
pure subroutines can be a pure
subroutines and pure functions can be
recursive also so a recursion is allowed
intent anat operations are allowed but
intent out operations are all out but
intent in operations are not allowed
okay so so that's it but that's it so if
I were to make a small correction over
here not a correction just an extension
however the intent out and interned in
out in turn a note variables can be
changed okay however internet not an
intern we're in turn order internal
variables can be changed okay this is
kind of logical if this is kind of
logical Thatcher thank you guys for
watching and I hope you guys learned
something in this tutorial and i'll see
you guys next tutorial bye