Database Management Exam > Database Management Videos > Introduction to Fortran Programming (Basic Level) > Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls
Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
FAQs on Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls Video Lecture - Introduction to Fortran Programming (Basic Level) - Database Management
| 1. What is recursive function call in Fortran programming? |  |
Ans. A recursive function call in Fortran programming is when a function calls itself during its execution. This allows the function to solve complex problems by breaking them down into smaller sub-problems. The recursion continues until a base condition is met, at which point the function starts returning values and unwinding the call stack.
| 2. How can recursive function calls be useful in database management in Fortran programming? | |
Ans. Recursive function calls can be useful in database management in Fortran programming as they allow for efficient and organized data retrieval and manipulation. For example, a recursive function can be used to traverse a hierarchical database structure, such as a tree or a graph, in order to search for specific data or perform operations on the database elements.
| 3. Are multi-function calls supported in Fortran programming? | |
Ans. Yes, Fortran programming supports multi-function calls. This means that multiple functions can be called within a program, allowing for modular and reusable code. Each function can have its own set of input parameters and return values, providing flexibility in program design and implementation.
| 4. Can recursive function calls lead to infinite loops in Fortran programming? | |
Ans. Yes, recursive function calls can potentially lead to infinite loops if not implemented correctly. It is important to define a base condition that will eventually terminate the recursion. Without a proper base condition, the function will keep calling itself indefinitely, resulting in a program that does not terminate and consumes excessive computational resources.
| 5. What are some best practices for using recursive and multi-function calls in Fortran programming? | |
Ans. Some best practices for using recursive and multi-function calls in Fortran programming include:
- Ensuring that recursive functions have a well-defined base condition to avoid infinite loops.
- Testing and debugging the recursive function thoroughly to ensure correct behavior.
- Using appropriate data structures and algorithms to optimize the performance of recursive calls.
- Organizing the code in a modular and reusable manner by utilizing multiple functions.
- Documenting the code properly to enhance readability and maintainability.
Text Transcript from Video
hello guys my name is Aaron and welcome
to my channel this series is a series of
tutorials on photon programming now in
the last tutorial we saw how to know
write functions and how to you know
compile functions and all such that some
functions can be written inside the
program within the within here some
program some function can be written
outside the program and some can be
written in a completely different script
you know now in this tutorial we'll be
seeing how to write the functions how to
write functions such that they can call
recur they can call other functions
inside them at the same time they can
call themselves again and again inside
them inside themselves know now for this
to work okay for this for me to explain
this process I have written a small
program here called as per comm the
script name is per underscore calm def
95 program call is per calm and let me
walk you guys through what's happening
here I star
I start with an X implicit none and then
I declare integers of kind 8 and I'm the
external parameter with the external
keyword so you got if you guys
understand what it means it this means
that this function per this is this is
this week a variable per this variable
come with the mm and this variable come
these are all functions integer
functions that will be that we will be
defining in a few minutes in a few
months and then I have in declared five
integer variables of kind eight namely n
R / 1 comma R and come to these will be
storing the values of permutation
combination of our first type
combination that corresponds to this
this you know this variable and come
that the combination that corresponds to
this this function and all okay now in
the using this print statement as the
read statements I get the value of n at
N and R from the user and then this is
where the function calls happen I
calculate the permutation we're using
this come function per by passing the
values of N and R I calculate the
combination using this function the
fungal of this function is that it
passes
a permutation value inside and then uses
the r-value to separately calculate the
supply to calculate R factorial and they
come up with the combination and finally
I used this comb function to do to this
car value to store value from function
to get the early calm function so I said
it does not take the permutation value
but it calculates a combination from the
scratch and in these statements I print
the value of permutation and combination
of r in in a using is and you are using
the values using a very sweet record now
let's go and define the functions okay
now to defy the function V notice in the
last tutorial that either you can define
them inside the program without the
external peril without any external
definitions like this or I can or you
can define within the within the script
Bill but below the program are in a new
entirely script whether you write it
below the after this program within the
script or outside it in a separate
script those doesn't matter that
actually doesn't matter it's kind of
independent and they're kind of or less
similar sooner so what I do is that I'm
defining all the functions in any new
new program now I create a new program
called as fact underscore / underscore
comma 2 square functor 95 which simply
means the factor it simply means this
one this program and how the functions
for a factorial permutation and
combination okay and now let me start
writing the let me start by adding the
integer factorial function and if you
guys noticed I have written written the
I just try to run this program earlier
and this function order to see whether
it's working or not I use this value to
I use this function to you know check
check for it and I'll walk you guys
through from the beginning now what I do
since the all this functions return a
value of type eight kind eight then I'm
going to define this function two as an
integer function right integers rate
yeah
right and this has to be a function I
come to the recursive recursive value in
a minute function and then I write fact
because fat is going to be the factor a
little value it'll is going to take a
value and now I'm going to end the
function here in the function packed
here and as always implicit lon
okay and then I write integer star eight
just elastics 8 and then intent in
indicating that this function will be
getting a value N and this value of n
will not be changed throughout the
running of the function now let's start
the factorial pass factor or calculation
for which I need an if statement now if
n equals equals 1 or n by some chance
equals 0 this is kind of a foolproof but
method but anyway ok then I'm going to
use define a new variable what I can do
is that suppose if I were to write this
as fact equals fact of say fact equals 1
okay that's so that looks fine right no
yes now what I can do is that I can
write fact equals fact of n minus 1 and
that equals fact star N and I'm going to
end this in this if statement
now this looks proper right but when I
compare this okay let me just compare
this I just get I get an error stating
that this fact is a not classifiable
statement okay why because but this
should not be the case right
I mean fact is the function name and
recursively calling recursively calling
it again and again but they should not
it should work right but it but the
practice it won't work so as step as a
troubleshoot
see suppose suppose just like the
previous program suppose if ever to call
using the external keyword fact save
this there to build this again I get two
more over I get two more compilation
error stating that this symbol factors
fact that one already has a basic type
of int integer okay but where you have
to throw another but so it means means
to say that you already have a
definition but this it cannot take this
definition again now what does this mean
well suppose if you have to you know
comment this out say this and then
compile this that data goes away so this
is actually causing us a problem now
this is there are a few reasons for it
first reason is that if you want to do
this kind of process where and you have
to call the same function again and with
inside the same function okay why do you
have to do you have to you have to make
sure this function is recursive you have
to make sure this function try recursion
recursion enabled now what does it what
does this equation mean it means that
one function can call the same or
different function again and again and
again inside the inside it inside itself
okay now for instance what we're doing
is that I'm passing available to this
function and this function here is
calling itself again is again but with a
different value of n and if I had to
look at how this process goes it'll call
this function itself again it's a
different value of n and ultimately to
let's say if the value is 5 this will
call fact 4 in this one and in that they
call factory and then it will call fact
2 and then end will call fact 1 but for
the fact 1 the request ends because the
fact 1 when N equals 1 this fact equals
1 so this will end up this will end up
go here and that will end up go to next
value next value next well in finally
and after everything is done after
everything is everything is done okay
this is no come over here and proceed
further
simple as that but if you want the if
you want this kind of recursion to be
possible you need you need this keyword
recursive to be present and now if I
were to become and compile this I still
get an error let's see let's see the
Lord looks at look what we get that it
says that fact one fact that one is the
name of the recursive functions and so
refers to the result very we'll use an
explicit result variable for a directory
question now what does this mean it
means that using the fat function here
so you need something you need something
to explicitly you mean since you are
using this function again and again as a
recursion you nee it says that you use
some other variable that you some other
variable to pass us an X to store the
vessel explicitly and pass it so meaning
a what this one what the compiler of
photon compound is telling telling to us
is that okay let the faction name be the
same but use a new variable to get the
to get the result and use that to pass
it out okay now instead of fact passing
the rest said it's the fat storing the
result I'm making the previous programs
let it define a new variable and let
that variable store the result and
indicate to the compiler that this value
is being returned then the return for
other programs wherever it's used now
that being said what has to be done is
that what I'm doing is that let I'm
keeping this leaving this internal one
okay then let me write this as fact 1
okay how to do that is that right this
fact 1 and let me say fact 1 equals 1
and here let me say a fact 1 is like
this ok
now this should be fired right I mean
this should be fine if a body favor -
you know what I'm doing this that I've
been creating a new variable called as
fact 1 and now I said in fact 1 equals 1
and here I'm calling fact 1 equals fact
of n minus 1 ok and then when that r is
requesting ends over this fact 1 equals
fact one star in so fact one will be the
one will be will be the one had to be
sending the result whatever to compare
this
okay no it just says that we need to
this is not sufficient enough we need to
give you some explicit result thing so
what I do is that in this part in this
program okay I gave this keyword result
result and then I type fact one and then
him/her to compare this you forgot to
compare this never to compare this this
shows that already this variable already
has the basic data type integer and I
don't need to find the second so because
why it's because of this function this
fact is this fact will return a value of
two integer of type 8 kind 8 since I put
in the result over here the same data
type goes to this so this it says that
this is true diamond this is extra and
not mean that so let me just remove this
off remove this off now if I were to you
know
compile this again I don't get any error
but just to be on the safer side to
ensure that you don't get any issue okay
I'm using this keyword return two-prong
to stop the to be on the safe aside to
stop the term and to stop the execution
okay awesome
as simple as that now if I have to
compare this again I don't get any error
perfect
now if you guys notice this is exactly
the same this is exactly the same
function like I kind of checked it over
here which I kind of walked you guys
through how it worked now with this
being with this being done let's
calculate the let's you know write the
code for the permutation function on the
permutation and combination function now
permutation function this will have the
data integer of kind eight now let us
define this as function and then let's
see let's look at the name we gave it
birth so it will have two values n comma
n comma R and then
and function but okay I type implicit
okay implicit none okay
integer type 8 comma intent in I passion
come on ah okay
now this is easy per will be equal to
fact of n type / fact of n minus R
simple enough extremely simple enough
and that is that is all you have to do
now fermentation is a permutation by
definition is given by n factorial n
factorial divided by n minus R factorial
so that is all you have to do now if I
were to compile this okay if I were to
compare this now what does it give me it
just gives me an error stating that this
fact as no as you know this fact has no
let's say any implicit data type which
means this function cannot call this
factorial function unless it is defined
so let me define this okay now just like
in the just like in this program where
in these definitions for per come and
come okay all right kind of external to
the program you have to mention the same
for this function per okay for this
function for this function that is
external to it so what do you do there
we type external okay and then we write
per oh sorry
not per fact hopefully okay sorry
hopefully this should work remove all
there is if you were to compile this
perfect now there aren't any errors
simple as that now let me just copy this
entire let me just you know copy this
entire stuff copy the entire stuff and
let this be
come because by combination we pass yet
come in come on are okay let this become
and this will work fine and this calm is
actually factorial of n times the
factorial of n divided by factorial of n
minus R didn't develop a factorial of
our okay and now I in this the key would
come and if I were to pass the if I were
to build this compile this
I don't get any error finally we just
have just one more function to do one
more function to do and that is integer
type type 8 and then function come and
then I pass / / and / and what was Eric
what was that again
yeah now this being said the you know I
mean ending it with ending here function
come with a mm cingulum in put in place
a non integer star
eight star eight intent in comma R okay
now calm easy calm equals yeah okay this
is fine calm equals / / fact of
factor bar okay and then I type integer
type 8 external fact because fat is
being used externally simple enough okay
now there is there is one more common
one more thing which we can do it means
in this function if you guys notice let
me if you guys notice now what I did is
that I passed the value of combination
inside and then I possible if I to get
the answer what if I call combination
inside this function again that's simple
as that what I have to do is let me just
create a new type here calm be calm be
and then I type calm be I like to just
calm 3 comma 3 comma 3 equals calm B of
n type income and R and let me just
print this again it's slight changes
combination 3 okay now let's go and
define this come to be what I do is that
I just you know copy this function pass
it here and what I do is that I just
rename this this just can't be
this is combi this is combi and here I
pass I'm using the perb
I'm passing the value n here so let me
say this as in comma R here and then I'm
going to call externally two functions
factored per now this per will give me
the value of how many permutation of n
comma R okay and then this function will
return factor so this from this function
can't be will be call it will be
colleague permutation as well as the
factorial of are to do all the
process okay now if you guys notice you
have one you have one one two three four
and five functions here and if I were to
compile this it works fine so there is
there aren't any errors now quickly
let's write a shell script and save this
up now the shell script sorry now the
shell script for this is welcome dot as
such now let me clear all the screen
when I write this I'll just click LS and
then type remove by removing all the
asset files object files removing all
the exe files if they are running and
removing all the mod files which will
come in the future okay and then I click
LS and then I take G Fortran - see now
instead of writing all the functions
like one by one okay what I can do one
one after the other what I can do I can
just write it star dot F 95 this is me
because is this former function will ok
this function this function of program
will work only in this folder this
script will work on in this folder so in
this folder this these are the only
functions that are a program that are
available so nothing to worry about it I
write it like this okay let me list the
files and then I type G for time okay
star dot o okay
and then write the object flag and then
type back on dot exe let me just list
the files again and then I type and then
I type per card exe this way this way I
am compiling I'm compiling these two
files in a single line single line
without any issue as simple as that now
now if you guys notice this is only a
recursive function all these functions
are not recursive so nothing to worry
about
I am adding to a report now let's
run this file in the terminal Mikey let
me just sorry
just all the files it's too messy here
let me clear this up unless now I have a
lot of object files and stuff over here
let me know this is the park on file
here here I don't know my neighbor is a
my neighbor listen to making noises
ignore about that okay
let me type chmod 777 per car God I
searched I searched all this you guys
know that this becomes an executable no
I just like bash calm not as such
hopefully compiled everything and if you
guys noticed yeah although it listed
everything it deleted all the data files
it shows that there isn't any execute
over no mod files and then he just lists
all the files then it creates all the
update files and then it creates the
executable file here and then runs it
it's asking for n that means the scale
say 5 and then a value of r3 perfect it
shows that the permutation of 3 and 5 is
60 there's a combination one combination
two and combination of 3 and 5 is 10 now
let's check we keep it let's check
permutation combination let's look at
you know there are a lot of things over
here ok let's look at the first example
there are any ok my internet is horribly
slow Internet is a horribly slow so
let's look at certain exa let's look at
certain examples let's look at certain
examples ok now here in this program
here in this floor here and this program
it says that they're looking for a
permutation of 3 out of 16 don't take 3
out of 16 / 16 bars okay and then let's
see whether they have combinations also
they have combinations also yeah they
have combinations also and yeah so if
you guys look at let's try this value
because they haven't worked it worked it
out properly there let's in this example
there are like 16 pool balls out of
which have to take three any order any
at three so this is a game with 16
factor about 16 - three factor which is
n PI to the by n minus R factorial okay
and the value should be three thousand
three hundred and sixty and ice at the
bottom and the canoeing the combination
is part of it
combination part of it okay the the
combination should be 16 factor by three
factor with my time 16 PI minus three
factorial so it should be 560 now let's
run our program to see whether we get
answer yeah
no the answer is 16 the value is 3 yeah
we get the permutation to be 3360 and
the combination using all the three type
all the three possible values is 560 560
as comparison works out as this answer
works out to be fine
perfect now congratulations guys you
guys successfully learned how to make a
recursive recursive function because of
set of function how to cause one
function inside the other without any
issue now in the next tutorial what we
will see is that we will try to write
one of these functions one of these
functions inside this main function and
let us see how you know the how you know
the dynamics work how you know how there
are no compilation and everything
changes and all now that's all I have
for you guys in this tutorial hope you
guys learn something
ok thank you guys for watching and see
you guys the next tutorial bye
to my channel this series is a series of
tutorials on photon programming now in
the last tutorial we saw how to know
write functions and how to you know
compile functions and all such that some
functions can be written inside the
program within the within here some
program some function can be written
outside the program and some can be
written in a completely different script
you know now in this tutorial we'll be
seeing how to write the functions how to
write functions such that they can call
recur they can call other functions
inside them at the same time they can
call themselves again and again inside
them inside themselves know now for this
to work okay for this for me to explain
this process I have written a small
program here called as per comm the
script name is per underscore calm def
95 program call is per calm and let me
walk you guys through what's happening
here I star
I start with an X implicit none and then
I declare integers of kind 8 and I'm the
external parameter with the external
keyword so you got if you guys
understand what it means it this means
that this function per this is this is
this week a variable per this variable
come with the mm and this variable come
these are all functions integer
functions that will be that we will be
defining in a few minutes in a few
months and then I have in declared five
integer variables of kind eight namely n
R / 1 comma R and come to these will be
storing the values of permutation
combination of our first type
combination that corresponds to this
this you know this variable and come
that the combination that corresponds to
this this function and all okay now in
the using this print statement as the
read statements I get the value of n at
N and R from the user and then this is
where the function calls happen I
calculate the permutation we're using
this come function per by passing the
values of N and R I calculate the
combination using this function the
fungal of this function is that it
passes
a permutation value inside and then uses
the r-value to separately calculate the
supply to calculate R factorial and they
come up with the combination and finally
I used this comb function to do to this
car value to store value from function
to get the early calm function so I said
it does not take the permutation value
but it calculates a combination from the
scratch and in these statements I print
the value of permutation and combination
of r in in a using is and you are using
the values using a very sweet record now
let's go and define the functions okay
now to defy the function V notice in the
last tutorial that either you can define
them inside the program without the
external peril without any external
definitions like this or I can or you
can define within the within the script
Bill but below the program are in a new
entirely script whether you write it
below the after this program within the
script or outside it in a separate
script those doesn't matter that
actually doesn't matter it's kind of
independent and they're kind of or less
similar sooner so what I do is that I'm
defining all the functions in any new
new program now I create a new program
called as fact underscore / underscore
comma 2 square functor 95 which simply
means the factor it simply means this
one this program and how the functions
for a factorial permutation and
combination okay and now let me start
writing the let me start by adding the
integer factorial function and if you
guys noticed I have written written the
I just try to run this program earlier
and this function order to see whether
it's working or not I use this value to
I use this function to you know check
check for it and I'll walk you guys
through from the beginning now what I do
since the all this functions return a
value of type eight kind eight then I'm
going to define this function two as an
integer function right integers rate
yeah
right and this has to be a function I
come to the recursive recursive value in
a minute function and then I write fact
because fat is going to be the factor a
little value it'll is going to take a
value and now I'm going to end the
function here in the function packed
here and as always implicit lon
okay and then I write integer star eight
just elastics 8 and then intent in
indicating that this function will be
getting a value N and this value of n
will not be changed throughout the
running of the function now let's start
the factorial pass factor or calculation
for which I need an if statement now if
n equals equals 1 or n by some chance
equals 0 this is kind of a foolproof but
method but anyway ok then I'm going to
use define a new variable what I can do
is that suppose if I were to write this
as fact equals fact of say fact equals 1
okay that's so that looks fine right no
yes now what I can do is that I can
write fact equals fact of n minus 1 and
that equals fact star N and I'm going to
end this in this if statement
now this looks proper right but when I
compare this okay let me just compare
this I just get I get an error stating
that this fact is a not classifiable
statement okay why because but this
should not be the case right
I mean fact is the function name and
recursively calling recursively calling
it again and again but they should not
it should work right but it but the
practice it won't work so as step as a
troubleshoot
see suppose suppose just like the
previous program suppose if ever to call
using the external keyword fact save
this there to build this again I get two
more over I get two more compilation
error stating that this symbol factors
fact that one already has a basic type
of int integer okay but where you have
to throw another but so it means means
to say that you already have a
definition but this it cannot take this
definition again now what does this mean
well suppose if you have to you know
comment this out say this and then
compile this that data goes away so this
is actually causing us a problem now
this is there are a few reasons for it
first reason is that if you want to do
this kind of process where and you have
to call the same function again and with
inside the same function okay why do you
have to do you have to you have to make
sure this function is recursive you have
to make sure this function try recursion
recursion enabled now what does it what
does this equation mean it means that
one function can call the same or
different function again and again and
again inside the inside it inside itself
okay now for instance what we're doing
is that I'm passing available to this
function and this function here is
calling itself again is again but with a
different value of n and if I had to
look at how this process goes it'll call
this function itself again it's a
different value of n and ultimately to
let's say if the value is 5 this will
call fact 4 in this one and in that they
call factory and then it will call fact
2 and then end will call fact 1 but for
the fact 1 the request ends because the
fact 1 when N equals 1 this fact equals
1 so this will end up this will end up
go here and that will end up go to next
value next value next well in finally
and after everything is done after
everything is everything is done okay
this is no come over here and proceed
further
simple as that but if you want the if
you want this kind of recursion to be
possible you need you need this keyword
recursive to be present and now if I
were to become and compile this I still
get an error let's see let's see the
Lord looks at look what we get that it
says that fact one fact that one is the
name of the recursive functions and so
refers to the result very we'll use an
explicit result variable for a directory
question now what does this mean it
means that using the fat function here
so you need something you need something
to explicitly you mean since you are
using this function again and again as a
recursion you nee it says that you use
some other variable that you some other
variable to pass us an X to store the
vessel explicitly and pass it so meaning
a what this one what the compiler of
photon compound is telling telling to us
is that okay let the faction name be the
same but use a new variable to get the
to get the result and use that to pass
it out okay now instead of fact passing
the rest said it's the fat storing the
result I'm making the previous programs
let it define a new variable and let
that variable store the result and
indicate to the compiler that this value
is being returned then the return for
other programs wherever it's used now
that being said what has to be done is
that what I'm doing is that let I'm
keeping this leaving this internal one
okay then let me write this as fact 1
okay how to do that is that right this
fact 1 and let me say fact 1 equals 1
and here let me say a fact 1 is like
this ok
now this should be fired right I mean
this should be fine if a body favor -
you know what I'm doing this that I've
been creating a new variable called as
fact 1 and now I said in fact 1 equals 1
and here I'm calling fact 1 equals fact
of n minus 1 ok and then when that r is
requesting ends over this fact 1 equals
fact one star in so fact one will be the
one will be will be the one had to be
sending the result whatever to compare
this
okay no it just says that we need to
this is not sufficient enough we need to
give you some explicit result thing so
what I do is that in this part in this
program okay I gave this keyword result
result and then I type fact one and then
him/her to compare this you forgot to
compare this never to compare this this
shows that already this variable already
has the basic data type integer and I
don't need to find the second so because
why it's because of this function this
fact is this fact will return a value of
two integer of type 8 kind 8 since I put
in the result over here the same data
type goes to this so this it says that
this is true diamond this is extra and
not mean that so let me just remove this
off remove this off now if I were to you
know
compile this again I don't get any error
but just to be on the safer side to
ensure that you don't get any issue okay
I'm using this keyword return two-prong
to stop the to be on the safe aside to
stop the term and to stop the execution
okay awesome
as simple as that now if I have to
compare this again I don't get any error
perfect
now if you guys notice this is exactly
the same this is exactly the same
function like I kind of checked it over
here which I kind of walked you guys
through how it worked now with this
being with this being done let's
calculate the let's you know write the
code for the permutation function on the
permutation and combination function now
permutation function this will have the
data integer of kind eight now let us
define this as function and then let's
see let's look at the name we gave it
birth so it will have two values n comma
n comma R and then
and function but okay I type implicit
okay implicit none okay
integer type 8 comma intent in I passion
come on ah okay
now this is easy per will be equal to
fact of n type / fact of n minus R
simple enough extremely simple enough
and that is that is all you have to do
now fermentation is a permutation by
definition is given by n factorial n
factorial divided by n minus R factorial
so that is all you have to do now if I
were to compile this okay if I were to
compare this now what does it give me it
just gives me an error stating that this
fact as no as you know this fact has no
let's say any implicit data type which
means this function cannot call this
factorial function unless it is defined
so let me define this okay now just like
in the just like in this program where
in these definitions for per come and
come okay all right kind of external to
the program you have to mention the same
for this function per okay for this
function for this function that is
external to it so what do you do there
we type external okay and then we write
per oh sorry
not per fact hopefully okay sorry
hopefully this should work remove all
there is if you were to compile this
perfect now there aren't any errors
simple as that now let me just copy this
entire let me just you know copy this
entire stuff copy the entire stuff and
let this be
come because by combination we pass yet
come in come on are okay let this become
and this will work fine and this calm is
actually factorial of n times the
factorial of n divided by factorial of n
minus R didn't develop a factorial of
our okay and now I in this the key would
come and if I were to pass the if I were
to build this compile this
I don't get any error finally we just
have just one more function to do one
more function to do and that is integer
type type 8 and then function come and
then I pass / / and / and what was Eric
what was that again
yeah now this being said the you know I
mean ending it with ending here function
come with a mm cingulum in put in place
a non integer star
eight star eight intent in comma R okay
now calm easy calm equals yeah okay this
is fine calm equals / / fact of
factor bar okay and then I type integer
type 8 external fact because fat is
being used externally simple enough okay
now there is there is one more common
one more thing which we can do it means
in this function if you guys notice let
me if you guys notice now what I did is
that I passed the value of combination
inside and then I possible if I to get
the answer what if I call combination
inside this function again that's simple
as that what I have to do is let me just
create a new type here calm be calm be
and then I type calm be I like to just
calm 3 comma 3 comma 3 equals calm B of
n type income and R and let me just
print this again it's slight changes
combination 3 okay now let's go and
define this come to be what I do is that
I just you know copy this function pass
it here and what I do is that I just
rename this this just can't be
this is combi this is combi and here I
pass I'm using the perb
I'm passing the value n here so let me
say this as in comma R here and then I'm
going to call externally two functions
factored per now this per will give me
the value of how many permutation of n
comma R okay and then this function will
return factor so this from this function
can't be will be call it will be
colleague permutation as well as the
factorial of are to do all the
process okay now if you guys notice you
have one you have one one two three four
and five functions here and if I were to
compile this it works fine so there is
there aren't any errors now quickly
let's write a shell script and save this
up now the shell script sorry now the
shell script for this is welcome dot as
such now let me clear all the screen
when I write this I'll just click LS and
then type remove by removing all the
asset files object files removing all
the exe files if they are running and
removing all the mod files which will
come in the future okay and then I click
LS and then I take G Fortran - see now
instead of writing all the functions
like one by one okay what I can do one
one after the other what I can do I can
just write it star dot F 95 this is me
because is this former function will ok
this function this function of program
will work only in this folder this
script will work on in this folder so in
this folder this these are the only
functions that are a program that are
available so nothing to worry about it I
write it like this okay let me list the
files and then I type G for time okay
star dot o okay
and then write the object flag and then
type back on dot exe let me just list
the files again and then I type and then
I type per card exe this way this way I
am compiling I'm compiling these two
files in a single line single line
without any issue as simple as that now
now if you guys notice this is only a
recursive function all these functions
are not recursive so nothing to worry
about
I am adding to a report now let's
run this file in the terminal Mikey let
me just sorry
just all the files it's too messy here
let me clear this up unless now I have a
lot of object files and stuff over here
let me know this is the park on file
here here I don't know my neighbor is a
my neighbor listen to making noises
ignore about that okay
let me type chmod 777 per car God I
searched I searched all this you guys
know that this becomes an executable no
I just like bash calm not as such
hopefully compiled everything and if you
guys noticed yeah although it listed
everything it deleted all the data files
it shows that there isn't any execute
over no mod files and then he just lists
all the files then it creates all the
update files and then it creates the
executable file here and then runs it
it's asking for n that means the scale
say 5 and then a value of r3 perfect it
shows that the permutation of 3 and 5 is
60 there's a combination one combination
two and combination of 3 and 5 is 10 now
let's check we keep it let's check
permutation combination let's look at
you know there are a lot of things over
here ok let's look at the first example
there are any ok my internet is horribly
slow Internet is a horribly slow so
let's look at certain exa let's look at
certain examples let's look at certain
examples ok now here in this program
here in this floor here and this program
it says that they're looking for a
permutation of 3 out of 16 don't take 3
out of 16 / 16 bars okay and then let's
see whether they have combinations also
they have combinations also yeah they
have combinations also and yeah so if
you guys look at let's try this value
because they haven't worked it worked it
out properly there let's in this example
there are like 16 pool balls out of
which have to take three any order any
at three so this is a game with 16
factor about 16 - three factor which is
n PI to the by n minus R factorial okay
and the value should be three thousand
three hundred and sixty and ice at the
bottom and the canoeing the combination
is part of it
combination part of it okay the the
combination should be 16 factor by three
factor with my time 16 PI minus three
factorial so it should be 560 now let's
run our program to see whether we get
answer yeah
no the answer is 16 the value is 3 yeah
we get the permutation to be 3360 and
the combination using all the three type
all the three possible values is 560 560
as comparison works out as this answer
works out to be fine
perfect now congratulations guys you
guys successfully learned how to make a
recursive recursive function because of
set of function how to cause one
function inside the other without any
issue now in the next tutorial what we
will see is that we will try to write
one of these functions one of these
functions inside this main function and
let us see how you know the how you know
the dynamics work how you know how there
are no compilation and everything
changes and all now that's all I have
for you guys in this tutorial hope you
guys learn something
ok thank you guys for watching and see
you guys the next tutorial bye
Related Exams
About this Video
|
4.73/5 Rating |
|
Dec 27, 2024 Last updated |
Video Description: Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls for Database Management 2024 is part of Introduction to Fortran Programming (Basic Level) preparation.
The notes and questions for Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls have been prepared according to the Database Management exam syllabus.
Information about Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls covers all important topics for Database Management 2024 Exam.
Find important definitions, questions, notes, meanings, examples, exercises and tests below for Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls.
Introduction of Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls in English is available as part of our Introduction to Fortran Programming (Basic Level) for Database Management & Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls in
Hindi for Introduction to Fortran Programming (Basic Level) course. Download more important topics related with notes, lectures and mock test series for
Database Management Exam by signing up for free.
Description
Video Lecture & Questions for Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management - Database Management full syllabus preparation | Free video for Database Management exam to prepare for Introduction to Fortran Programming (Basic Level).
Information about Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls
Here you can find the meaning of Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls defined & explained in the simplest way possible.
Besides explaining types of Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls theory, EduRev gives you an ample number of questions to practice Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls tests,
examples and also practice Database Management tests.
|
Explore Courses for Database Management exam
|
|
Signup for Free!
Signup to see your scores go up within 7 days! Learn & Practice with 1000+ FREE Notes, Videos & Tests.
Related Searches
mock tests for examination
,study material
,Objective type Questions
,Free
,MCQs
,ppt
,past year papers
,Summary
,Important questions
,Previous Year Questions with Solutions
,shortcuts and tricks
,Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
,Sample Paper
,Exam
,Extra Questions
,Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
,Viva Questions
,Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
,practice quizzes
,video lectures
,Semester Notes
;
Study Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls on the App
Students of Database Management can study Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls alongwith tests & analysis from the EduRev app,
which will help them while preparing for their exam. Apart from the Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls,
students can also utilize the EduRev App for other study materials such as previous year question papers, syllabus, important questions, etc.
The EduRev App will make your learning easier as you can access it from anywhere you want.
The content of Fortran Programming Tutorials (Revised) : 033 : Recursive and Multi-function calls is prepared as per the latest Database Management syllabus.
|
© EduRev
|
Education Revolution
|
|
Signup to see your scores
go up within 7 days!
Access 1000+ FREE Docs, Videos and Tests
Takes less than 10 seconds to signup