Advanced Fortran Programming : 015 : Dummy Variables in functions 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 this tutorial we will be looking
at one interesting concept that can be
adopted and Fortran especially for
functions and subroutines call as dummy
variables now these dummy variables are
not similar or not exactly the same
instead of the optional arguments as
optional variables or arguments they are
entirely different
okay now using dummy variables you can
call you can use some kind of a
recursive kind of functions recursion
like operations using with dummy
variables to make a certain job nice
nice and easy
well you may not understand what I speak
right now but if I go through the
program you might understand this nicely
okay what I have here is that I this one
this program will will calculate we will
do two points to power options two
things first it will define we're
defining a function that will calculate
the integral power of certain variables
suppose like suppose if you want to
calculate and power the fourth power of
some value at 60 power or some value
something of that sort then it is
possible okay then this function is and
that to another pop that to on the
positive side I have to mention that
positive integral power of another
function this function will do this
function will do it nicely and in the
second function okay we the second
function will be carrying the value of a
polynomial at at X at some point X okay
now the program called program name is
dummy underscore VARs and we have an
implicit man
I'm setting an integer P equals 3 and a
real value B equals 3 v equals 3.0 this
can be 2 or anything that doesn't matter
okay what we'll be calculating is that
the third power of the you know we will
because this power will be actually be
power P simple as that okay and then
they research for the first where first
function
the pastor integral power for the second
function okay I mean we need two more
I'll explain this one this line is an
external external attribute is where we
indicate the definitions of power and
the poly okay this power is nothing but
a power function that we defined over
here and this poly is nothing but a
polynomial function that we define over
here I'll come to that in a minute okay
now what I do is that here in this line
I set the value of x to be 5 and I set
the value in a call as X and this had to
be Phi and poly underscore Val will have
the pole will have this polynomial value
at the end okay and finally not finally
we are going to say we are going to
define an integer parameter called as N
equals 2 N equals 2 here and that that
value will be used to define an array
and this array has dam has indices from
0 to n so this is a 3.3 valued array
here 3 3 valued a real number array okay
and what are you going to do is that we
are going to set the coefficient of a to
beat 1 to 1 okay what this a is going to
do is that a will we have the
coefficients of the polynomial okay
now this 1 to 1 this actually say this
what I meant in this in my program is
that if it's a it's 1 to 1 then it
actually corresponds to the coefficient
coefficient of 1 2 and 1/2 and 1 here so
this actually corresponds to 1 plus 2 X
plus X square that polynomial a
polynomial suppose if we have another
value something of that if your honor if
we want our other value at the right we
add one more value at the right then
that that value will be the coefficient
of the cube X cube and the other value
after that will be the coefficient of x
power for the polynomial okay so this
can be pleasant - no problem ok now now
if I for this three set of three values
it wrap it represents the polynomial 1
plus 2 X plus X square okay and this
value and the
value of this polynomial at x equals 5
is 36 because it's if you guys notice
this is nothing but X plus 1 5 X plus 1
square identity a polynomial so if x
equals pi then the value of this
polynomial is actually 6 square so the
third is X so it's simple enough okay
and then they I call the power function
over here and the poly poly function
poly function over here and then
printing the the power P of B is how is
this the coefficient the polynomial here
and then the value of the polynomial X
polynomial at x equals x is this well
I'm going to get that I'm going to print
the value here and I'm ending the
program and now let's look at the
function parts of it now this is where
everything goes interesting now what I
do is that I am NOT doing any recursion
over here I'm going I'm not going to do
any requests over here what I'm going to
do is that observe initially I get the
value and as an intent in okay and I get
the value X just like that it's like
just like a usual function okay and
they're using the value of N and define
the size of the matrix size of the array
a perfect fair enough no problem now in
the integer I define a new integer for
me I call us I nothing much I set the
value of poly to be 0 initially and now
this is where this is where everything
becomes interesting I said to do loop
that varies from 0 to n okay and I said
Polly to be equal to poly plus a I a a
Phi star X power I now what this will do
now what this will do is this will this
will be a poly 0 this will calculate a 1
a naught plus a 1 X plus a 2 X square
plus a 3 X cube and so on and so forth
like that with that is it easy with the
indices matching the indices matching
the subscript of a naught a 1 a 2 a 3
and so on
perfectly but the the interesting part
of this function is in this function
call is that I am using this function
call here
and I'm using the function called here
but I'm passing it without any arguments
okay
that is the specialty of this function
and if you guys not this because I
passed this in this way okay what have
what happens is that then this function
is called on itself without any
arguments well now here I'm cutting this
function is calling itself without any
arguments here there are any arguments
okay so as if now what this means is
that this means that X becomes something
like a dummy variable so only when the
first time it has been called only when
the first term has been called the X is
called as an a proper variable and even
a the entire array any she is initially
called as a proper variable but after
this do loop in this do loop these are
called as dummy variables because I'm
not passing these variables so what
happens is that when there it when the
kind of this kind of a call happens
every time okay X remains as it is the
value of air remains as it is okay only
the index positions are only the index
pushes is a different index which these
are occupied here we are used for every
do loop ultimately what happens is that
in when I use this polynomial function
okay the matrix the array a remains
preserved okay and the value X also
remains preserved throughout this
internal recursive call okay and if you
guys notice I did not use any recursion
over here this is an advantage of dummy
variables okay now in this bra in this
example X and ay they are dummy
variables okay and if you guys notice
you can PI you can you can make current
we can make an array also add as a dummy
variable or do this a single value but
even an array as a dummy variable so
what happens is that this will this will
initially be 0 first in the first
iteration it will K it will calculate a
naught which is a not a 0 times X power
0 so this was written only a not in the
second time it will calculate a naught
plus a 1 times X the next time a there's
that some +8 a 2 times X square then 8 3
times X cube a 4 times X power 4 and so
on and so forth depending on the value
of N and depending on the value of a
this like that it just goes on so
ultimately to calculate the value of so
ultimately calculate the value of
polynomial because in all these times
the value of x is known and it's being
preserved and it's being utilized some
kind of utilize as if some kind of a
symbolic expressions kind of a thing so
it's preserved over here so this works
fine now let's look at the power
function power function is again this
power function is again an indication of
dummy variable but this is a rather a
simple dummy simple function where I I
get the value n I get the value X okay
and I get an integer I iris at the
initial power value to be 1 and what I
do is that I run I run this in the
reverse order I run this in the run this
in the reverse order what I do is that
even in even if it even if you don't
mind in the reverse order even if it is
power order also it doesn't matter
actually doesn't matter actually what it
does is that it just calculates the x
times power ok so initially the power is
1 so it will be X into 1 so X next time
it will be X into X so x squared next
time it will be x times X cube X square
so X cube X times X times X power 4 X
cube its X power 4 so ultimately this
value gets repeated again and again in
the multiple in the country chain of
multiplication and ultimately it will
get X power and as the output X piranhas
are put at the end of this do loop ok
and that value gets and this value so
this value over here gets printed over
here simple as that
all right now let's enough of me talking
let me let's run this program compile
and execute this and there you have it
the power of 3 the power 3 of 3 is 27
because what I mean is something like
theta you can do if you want to read
this properly you can say something like
the third
power of three is 27 R is 3 power 3 is
27
okay and similarly the coefficients of
the polynomial are 1 2 and 1 okay which
is what I entered here it is actually
printed and the value of this polynomial
at value of this polynomial at x equals
5 is 36 because it's quite evident with
no quite evident because this polynomial
is actually x + 1 square so x is 5 so
the answer is actually 6 6 5 + 1 square
so 36 square so 36 so it is quite easy
to percolate similarly let me let me do
some let me do a little trickery let me
make this 3 here okay and here I let me
comment this out okay
let me put the value a equals 1 comma 3
comma 3 comma 1 sorry 1 okay this will
be 1 plus 3 X plus the 3 X power 2 plus
X power 3 which is nothing but which is
nothing but your X plus 1 cube X plus 1
cubed polynomial so sorry so value at at
x equals 5 this 6 cube so it's 200 and
216 okay now let's check this out and
before that lets me child try this 210
so that the third power of 10 is
thousand so this should work out fine
okay so let me check this out so if I
were to compile build and execute this
yeah perfect the power 3 of 10 is
thousand which is fine and the
coefficients of the polynomial are 1 3 3
1 so it's 1/4 it's a polynomial of order
3 degree 3 so you have an excuse so the
value of the polynomial at x equals 5 is
actually six cubes or 216 and dairy have
it properly nine properly and nicely
okay now this is the advantage of using
dummy function dummy variables so
instead of using subroutines sometimes
for all the conditions this kind of
option may be used accordingly instead
of using a recursive function or
recursive subroutines okay and if you
guys notice we using this option you can
write the factorial of a number also
want to try okay let's do that let's do
this okay let's do this okay let me
define an integer let me define an
integer of type eight and let's say f 1
and then fact fact 1 and let me define
this as integer type 8 type 8 comma
external external and then I use that
function simple fact function okay now F
1 equals Phi ok so part should be equal
to 120 because fact 1 is actually the
fact 1 is actually the factorial of this
function so let's write it over here
fact 1 is actually is actually fact of
how do we let's see fact of sorry F 1
simple okay now let's print it over here
print the factorial of factorial of F 1
yes comma fact one okay now let's write
the function the left side the function
are we here let me put this at the
bottom its integer right integer type
eight function what did it in order to
keep in the top fact okay fact I pass
only x over here like so okay let me
pass in so it doesn't matter okay and
end function fact okay and then I type
implicit man implicit man okay then
integer of kind eight I'm going to get
the value intent in so intent in so what
what this will do is that now what this
will do is it will get the value n okay
and okay
let me see the integer integer eight I
okay this is a local variable I okay now
I'll set fact to be equal to one
initially okay and now we need a do loop
again do I equals 1 to n fact equals
fact star I faxed RI and do alright
simple enough okay now what this what
this function will do is that it takes I
n as a dummy I give it once again but
this n gets used over here okay so when
I run this function run when I run this
part of the function it does not take
the value and so it reached end as a
dummy
just multiplies again and again with AI
every time so initially ie I practice 1
so it is 1 times 1 so 1 next value of I
it's 1 times 2 so 2 then X values 2
times 2 so for next time it's 2 2 times
2 times 3 is 6 then 6 times 4 is 24 and
then 120 of that sort and if I keep
since I kept and f1 equals Phi this
should return 120 so to compile this for
not bad no error in the first run will
this and execute this perfect this is
exactly the process exactly what we saw
but this result what we saw here is the
s classic it's simple extremely simple
now imagine how I imagined instead of
doing a recursive function this is much
easy isn't it okay using dummy argument
this is much easy okay and we get it
right
so I perceive at I suppose if you had to
set this to you know 10 ok come by build
and execute sorry sorry compile build
and compile build and execute this okay
I didn't I think I did save this yeah I
think I did say this ok now suffer to
come pile build and execute this I think
I place the wrong value over here
something okay I think I'm not
compelling properly build and execute
this
hmm
it's the still showing 5 equals 120 all
right why does it so why does it die
that's it okay let me yeah I think it's
in the desktop I think it said the
desktop I let me just edit this dummy
was and this table file also they might
be causing some issues okay now they
forgot to compile build and execute this
the factor of the fire is still 120 why
is that horse due to change the wrong
value over here oh
oh sorry I was extremely sorry I didn't
notice this should be changed I was
obtaining the wrong direction so I was
changing the wrong place so if I were to
set this to 10 you know why not let us
say that let's set the value to be 10
here so this should return since if it's
x equals 10 then this polynomial should
return this third order punished alert
on lemon cube so 1331 so let's check
this out compile build and execute this
yeah perfect
it returns the tenth factor a nicely and
then it returns that pie returns to the
powers nicely and even the polynomial
nicely nice perfect now that's all I
have for you guys in this tutorial thank
you guys for watching and I'll see you
guys in the next tutorial hope you guys
learned something in this dummy
variables dummy variables function thank
you