Fortran Programming Tutorials (Revised) : 040 : Modules + Array Valued Functions Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management

hello guys my name is Aaron and welcome
to my channel this series is a series of
tutorials on photon programming now in
this tutorial we will be looking at
functions which can't return array
values and then Fung and then how to use
pong a facility called as modules or
modules in Fortran now if you guys
notice this is the exactly the same
program that we saw in the previous
tutorial okay the cap and the program
that helps us to write didn't find the
solution of a system of simultaneous
equations we had cameras rule Kramer's
rule okay now what I made what I made
here that I just made some small
adjustments to it I just included this
new statement called us use maths one
okay now where did this come from
and this comes from this file over here
now this is the same file that we saw
last time but with the little changes I
just made this file as a module now what
a module module is in Fortran is this
it's a collection of functions and
subroutines in an orderly manner suppose
let's say suppose let's say you have say
20 functions or 20 functions and
subroutines that you not like to use
again and again for several purposes for
instance this determinant function we
need this Kravis part but this
determinant the function calculation
catalytic function this slice the
subroutine might be used for many
purposes many purposes other than you
know solving solving the solution
finding solutions using Cramer's rule
okay now suppose if if I were to make
this make file like this number to make
a file like this and you say again again
what I have to do is that so I just have
to copy this content and play plays
place this again and again
replaces but what if I can make this
file just I can just cop make a copy of
the copy of this file alone in one
single place and I can use it multiple
locations okay that'll be nice right and
besides what missus what if I can you
know group them together group the group
these functions and subroutines in such
a manner that in such a manner that they
they they behave like they behave rather
as a team okay module helps that what
model does is it makes sure that all the
function subroutines defined inside it
behave like a team we have as a part of
a team okay
they are all be they become internal to
it and modulus is something like a
program but but it needs a program too
well so it needs a program to know
invoke it okay now what I've done is
that to make a module here what you need
is that you just have to define all your
subroutines function just like in the
previous just like how you define
normally okay and what do you do is to
start a module write the keyword module
and then write the module name okay and
then and then to ensure that you have
written to make to indicate to the mod
compiler that this module has these
files and all the subroutine this
subroutine this recursive function and
many others you have to either keyword
contents just like how you you know
include an internal procedure and
program by using the world contains and
defining them you have to define the
functions like function subroutines is
an inside a module like this
now there are a few notes here I also
wrote okay
the functions are inside a module then
other functions and subroutines inside
the module can access it easily no
external referencing is required what I
mean is see
suppose if I did not write this module
well suppose if I did not write this
module let's say okay what what will
happen is that this subroutine crash
needs to needs this function I mean see
this the subroutine cram needs the term
data function externally has to use it
so I have to define this as real studied
external double colon def to indicate
that this function this a definition for
this variable or this function is
outside subroutine okay know what thing
is if you have to write this in a module
if I write this in a module you know all
of these become a part of the same
program so that means separa this
becomes part of the same script or the
same group so because of that I don't
need this anymore
I don't need this anymore all right
that's one of the advantages you get if
you write in there fried things are as a
module instead of become it so if all
the files all the subroutines
subroutines and functions becoming
external to each other
they become kind of internal to each
other so in the sense one knows exactly
the by the definition of the other s and
stuff so you don't have to explicitly
define an external keyword inside the
functions and subroutines to make you
make your life simple now in all of our
programs what we did is that we didn't
different module and all to go go ahead
with this reason because the number of
subroutines we use and the number of
functions we used we're extremely small
so we didn't have the nests we never had
the necessity to write modules right the
right the module so we just go ahead
yeah so we just wrote this external key
external definition line you know all
the four subroutines are functions it
uses other functions and all and we went
on with it
but in NASA imagine if you are working
and really serious project where and you
have to use say 30 functions or 40
functions and several other subroutines
I need subroutine uses three to four
functions and all okay of different
different return types if that being the
case this right I mean writing such
external statements for every function
that makes your life really hard to
follow really hard okay and this this is
and whenever you come PI it will just
get so many errors just because the the
external definition has not been may met
with okay now even this this way things
become really easy to follow things
become really easy to follow and that's
why I wrote here you don't need any
external referencing needed inside the
module for all the functions okay
at the same time there is this is
something you have to keep in mind
regarding the name the module name this
and the five main need not be the same
this is a module name I'm David Matz one
okay and the model the file name is matt
underscore mod okay but they need not be
the same but it is okay to have it is
okay to be the same in general it's
better you have it make it same okay if
the file name is different the file name
is different meaning this is different
from the module name then the over the
object felt that you will get while
compiling this file will have will have
the file name okay now if I compile this
the the object fire will be match
underscore motto whereas the module file
dot mod files name will be Matt Swan dot
mod okay and now when that being said I
have to use the dart mod files name
inside the call while dot o files name
for building an execution I'll explain
you guys what what I mean I just open i
just opened the shell script okay i just
open the shell script and see if I had
to run if I were to run this stuff
others in the terminal LS okay this is
what I get here
I didn't run this I just explain you
guys this is the module at the file name
is Matt underscore maraad f95 when you
compile this okay you will get an object
file like this math and math underscore
mark and then you will get done a module
file call us maths one dot mod
all right and now and now suppose if
they were exactly the same
let's say you know what you'll get this
this both this from Dartmouth feather
and the dot o file will have the same
name okay
and whenever whenever to refer this
module inside the program I should use
the module name this name match what not
this if you had include this this will
throw an error but I have to include
this so for practical practical purposes
whatsoever it's recommended to say have
the same name for module and the month
all right and now there is one more
thing you have to keep in mind you can
define a module inside the program
itself the sense is there for program
script itself then it's like this you
can copy all this okay you can copy all
this all the way from here copy all this
okay and you can decide if you're
defining module it should be
I bought the program I bought the
program and I say that to you know save
this temporarily and you know compile
this not to compare this this will not
show me near but he said to know have to
cut this up delete this know cut this up
and throw to put it at the bottom save
it and then compile to compile this
surprisingly doesn't throw mean error
maybe it's because I mean maybe it's
because the mod file are still available
and I just remove the mod
okay look if you check your thing no I
forgot to compile this it throws me in
throws another alright because it's a
that master on that model is not
available
okay since I've defined this here but on
the other hand were to cut this cut this
and places at the top say this if I were
to compile this it works fine now why is
the discrepancy see that this
discrepancy is because this margin then
this program is being executed here it
requires the module first to be
available okay now when you run the when
you compile this when this program gets
compiled first okay this part of the
this part of the program you know the
beginning part of it is the module and
this compiles for this compiles first
and when this composite produces the mod
file okay and then it goes to compile it
goes to compile the program now when
this Beaman this order is followed the
match that one module is available so
the program doesn't throw any errors
whereas if I were to know place a model
behind the program and we execute this
the program will run first and since the
module part has not been compiled has
not been compiled okay this match one
dot mod will not be available so we'll
just throw an error stating that this is
not present okay similarly okay yeah I
can you know what I can do is that I can
you know I can use the word can take
contains and write the module inside the
program itself inside the program itself
and for this I think I don't need I
think I have fortunate I don't think I
don't need this okay
anyway I'll just delete the mod file
here
be available here click Alice there will
be a mod file here
just remove the mod file ok
the mod file is not there ok no further
turn on compile this
ok it throws me in error
okay I'm next put a module statement in
contain section okay I think this okay I
think this contains need not be there I
suppose
and expect unexpected Maru statement and
contains okay apparently I think
apparently you are not allowed to enter
a module inside the program apparently
you're not allowed to enter a module
inside a program adding that it's
everything is fine okay so this is
something you have to keep in mind I
think you should not allow you should
not ask for my understanding goes like
you are not allowed to write a manual
inside the program but anywhere anyways
this is something you have to keep in
mind okay and there is this one more
thing I have to tell you and one more
thing I have to tell you regarding
modules this is done and this this is I
mean what you have to do is that when he
was up when you write a module in a
separate file like what we saw I what we
saw what happens is that you have to
compile the module module file first and
then the then the file that you're very
in working in the module second this
order has to be made with this order has
to be mandatory okay even if you are
compiling multiple files together the
module files have to be compiled first
and then the gern and the programs that
call the module has to be compiled in it
later and once these are compiled
properly okay the compiled properly the
order in which you compare the object
files may not be the same for instance
what I do is that I will just remove
this okay remove this and then terminal
what I do
bash this you get the shell file here it
works fine the order doesn't matter as
long as the object file is available
object files are available the order
doesn't matter because the compiler
knows okay without it we'll merge these
two so it will knows optimizer and all
so it turns out to be fine all right
this is something you have to keep in
mind and and then the suppose if I do
not cut this and places and places here
and they had to call the same crime
misrule again it will throw me another
because it says that the mass that one
file is not available because why
because the module has not because
because of this line the mod files are
deleted mod files are deleted so that's
the reason this mod files are deleted
and simple as that now if ever - and
this he just throw it just works out
fine perfectly fine and now there is
just one more concept I have to tell you
guys before I had this before in this
tutorial ok there this there is fun
there is a speciality that the functions
can do when it's written in modules
functions can return erase erase when
they are when they're written inside
modules modules and I'll explain you
guys how this is a program this is a
program where inmate calculates the
factorial of 10 numbers N equals 10 then
10 numbers I the numbers are stored and
stored in this line I have the sizing
high trading variable I to save them and
I'm allocating the all the first to 1 to
n values with the value of I so the
numbers are from 1 to 10 here ok and
then um fact is actually the factorial
of all these numbers is an array of
array storing the factorial of all these
numbers ok well you may not want it or
do you want you to keep in mind is that
this fact here takes the number number
my number array and the total number of
the total number of values in it and
that returns an array that will have the
factorial of the corresponding factorial
of the
here into this factor into this fad and
then I'm using this do loop to print to
print the values to make this possible
what I've done is that I've used this
use that I use this factorial program
that'll program here here and I use the
use fact one to use that and now here if
you notice the more the both the module
name and the file name are the same fact
one now we here I've defined this
function over here is inside this module
now what does this do this does is that
this function it will take it will take
the number and then I'm taking it as
intent in I'm taking this number as a
dimension of size en and interned in
defining to hydration I did a variables
I comma J and defining an integer
variable fact just for simplicity
simplicity and then defining the
function name the function name as
integer of type air and dimension okay
usually we write the type of the dur
function there a type of the function on
the top here I'm writing the function
definition I mean the function return
means function return data type and then
the size size of the returning variable
here inside the function
this again is allowed okay that's one of
the facilities that that's one of the
flexibilities available for an okay
since I define this now I have explained
and by this I'm explicitly mentioning to
the program that this function this
function is actually an array that
returns multiple values okay and then
what they do is that I just start the do
loop the same the do loop mechanism V so
I know one of her previous programs I
said I just start fact equals one fact
equals one
i-ight radii trait from I equal to one
to n I equals 1 to N and then I just you
say I just had a second to loop which
which I traits from I equals one to that
now the current number to be calculated
and then I said the fat equals one here
so this will just give me the fact
this will just calculate the factorial
at the at the end of this is looping
segments and then stores this fat value
in the pattern of the given number okay
this low do loop I traits said I traits
n type this outer loop I'd rich n times
sorry
outer loop I it is n times and thereby
working out working out all the
arithmetic and for at all arithmetic for
all the numbers and then saves it to the
fat number and that value and this
entire array gets returned his entire
array gets returned here now if I had to
you know let me just click LS let me
remove all the files with mod all the
fires with exe and all the files with oh
yeah perfect
no I show you guys how this works
suppose if I were to you know write this
function write this function I'll just
copy this it closes a no I don't need
these okay suppose I were to write all
this function here here okay and I don't
use this use fat operation okay if I
were to you know come if you were to
compile this it just throws me that it
is throws an error stating that hold on
hi guys welcome back I just got a call
anyway coming back suppose if I were to
define a function will copy the function
here and write it here you know the
uncompelled this it will just throw me
in error okay it just says that fact
numbers no implicit none there's a
mismatch kind of a thing okay
it's possible because you didn't define
this externally alright now if I were to
know compile this so that if I were to
compare this I still get an error okay
the external attributes conflicts with
the dimension stuff okay okay the Lada
it just throws me the main issue that
there are some external the dimension
dimension conflict and so okay what I do
is that suppose I just remove this
dimension part of it okay run this again
it's still showing me some problem
setting that that's explicit interface
required and stuff okay now there's a
simple way to do this I just replace
this asset this okay it's a simple way
to do this this may not work most of the
time especially for this kind of a
program so what he could ask you are a
single by returns just a single value
this external keyword and stuff will
work for work out perfectly fine but if
it's you know dimension like this
it needs some it needs a little more
treatment to work with but a simple way
is that there are two simple ways one
use a module right this entire functions
are no module and like this and compile
the module along with it along the file
and you'll be ill you okay with it or
else there's another way this is the
first other way what you can do is that
I can just cut this and use contains and
write this and make this function as a
procedure within the program now in
order to compare this it will work fine
if I were to build this and execute this
we will work out fine hey it just works
out fine okay addy now this is something
Habakkuk government defining functions
that return arrays are a bit tricky
actually all alone in this file flooding
them may be erroneous especially like
that may be all right sometimes it might
work you know I I think there is a way
to make it work like this but I'm not
sure as of now if I find I let if I find
a let you guys know okay well if you
guys find if you guys find I need you do
let me know I'll I'll correct this and
learn at all
so and defining that but the but if you
have to define them as like with the
external and diamond schema like this
this may not help help you properly but
the soli solution is either define that
function entirely within the program
like this using the keywords content so
that the function becomes a internal
procedure for the program okay like this
or define it in a module like this and
use the module accordingly know it for
that or remove this off and I don't need
this here now if I were to compile this
so to compare this I have a fact
SH file here - dot search what we'll do
is that will do the same operation I'll
just open the file for you guys this
clear stuff removes all the mod files
compares compares the fact module first
then compiles the the function second
and then generates the offe Iles
generate the object files merges all the
object files to produce an X you know
call us fat dot the exe and then to
answer for executable now if you guys
notice in this demo all the object is
just lister clears everything list out
all the files listed all the files are
available it almost all the object files
mod files the exe files since there
aren't any here just shows an error but
if there are it won't show it won't show
like this but nothing but no matter
there's nest all the face then it
compiles the first file and produces a
mod file mod file
ok we'll compile a monitor produces a
mod file and then and also an object
file ok it produces these two when
comparing this and then it produces an
object file and come and compile this
and then it just merges these two to
produce an executable like executable
this easier to fire this ok and then
branches and the results are like this
suppose if ever to you know
changes to say that may not be a match
my cell just give a twenty okay if and I
ran this again it'll just work out fine
okay now this is how you define modules
this is how we define modules and how to
you know how do I say yeah and how to
make functions that return multiple
values simultaneously multiple values
simultaneously as an as an array okay
well if you guys notice this is exactly
the way in which certain functions like
cos function sine function and da which
took arrays returns an array also and if
that this is kind of the motivation
behind how those functions are actually
defined okay now Miss to Torrez getting
long very long and that's all I don't
have anything else to say for in this
tutorial that's all I have for you guys
in this tutorial okay
thank you guys for watching and see you
guys next today do please subscribe to
my channel bye