Advanced Fortran Programming : 030 : Elemental Procedures Video Lecture | Introduction to Fortran Programming (AdvancedLevel) - Database Management

hello guys my name is Aaron and welcome
to my channel this series is a Cesar
tutorials an advanced Fortran
programming now this is the penultimate
topic we will be looking at in this
total in the series and this is a very
small topic called as elemental
procedures now before I go to element to
procedure I just want to mention a small
topic ok small concept see if you
remember the mod function or absolute
function or absolute function so are
some functions some some functions which
are available in Fortran ok further to
recall them properly
let me let me just find them yeah like
the minimum value minimum functions or
maximum function or sine function or the
absolute function and all ok
if you guys take these functions ok
regardless of whatever datatype you give
to them
there are they did they do the same
process for instance if you do if you
just give them a call let's take an
example of absolute func absolute value
ok if we give a integer value into it it
returns the path it returns the past in
modular modulus fine even if you enter a
complex number in third it returns the
magnitude of it if you return if you
send a real number anybody again sends
the absolute of it but in the real sense
ok so if you guys notice these functions
are kind of functions which are in which
work which work in a similar in a manner
which sometimes but the PACU is
sometimes different for different data
types
ok but for similar some data types it's
exactly the same so these are like kind
of does not have very less dependence on
the initial data type all the variables
are being sent into it ok if you guys
notice these are actually called as
element with some elemental procedures
or elemental elemental procedures
ok that's the main thing meaning what is
an element procedure is that these are a
lab procedures which have very less
importance and significance there on the
size of the variable as well as the
sighs as a variable as well as a time of
the rail at least the type of variable
has less significant has a little more
significance that size of it does not
have any significance and that's the
reason why even if you sent suppose if
we want to find the magnitude of an
entire array a two-dimensional array of
three dancers everything okay descend at
the entire two dimensional array into
absolute function it returns the small
it returns the positive values of the
positive values for each and every into
every entry of the array that's not that
it does not bother about the size it
just works out works fine except mine
and since the value now how is it
possible like because it was able to it
works for even the smallest of valleys
and even for the largest embarrassed how
is it possible it's possible because of
elemental precision what is that what
does these do or that they don't care
about the size is take the value to cut
the data type and the job accordingly
that's what they do okay and that is
what we're going to do over here okay
I just have a module called as elements
one in which I've defined three
subroutines e^x underscore R e^x
underscore I and E X underscore L which
are exact Quinta's which are essentially
the same same thing they what did they
do is just exchange numbers mean they
swap numbers simple as that I take two
entries x and y as intent in out meaning
the values are Karen they'll be modified
okay I use a temporary variable and then
using the temporary variable I I just
popped I just send the value of x to y
and Y to X okay so when they when the
X&Y come with certain values they get
swapped and they go out with the others
value when they come out of the
subroutine this works for real function
this subroutine works for real functions
with real values this subroutine which
is exactly the same as above but it
works for integer for integer values
whereas this function this subroutine
works for logical values that's it okay
so what I have is that I have three
elemental subroutines one for real
one for integer and one for logical okay
now what I've done is that I have three
three subroutines I mentioned them in
the module elements one now what I do is
that if I were to make
sure that if you were to use a common
name and you know I don't have I don't
commonly but your which which is kind of
independent of the data type or very
less independent of the data type what
can be done interfacing is possible
isn't it that's what we're going to use
if you use the interfacing for
possibility over here okay which what we
saw in the last time it says that we
need another module units and
interfacing has to be done so what are
doing is that I'm creating another
module called as elements to in which I
used all the subroutines of elements one
and then I define an interface block
over here okay
the interface blocks name is exchange
and inside that I have three module I
have written the three module procedures
e^x underscore re X and the square I and
II X underscore L because of this if I
just call exchange if you just call
exchange it doesn't waste of the
datatype I sent into it either or not
these func
one of these possible procedures will be
called accordingly that's it okay that's
that's it now what I'm going to do is
that I make a create the modules and
create the interface now I'm importing
both of them you sing this line use
elements to in the program and what I
have in the program is it may look big
but it's actually simple I like I'll
just walk you guys through I use the
module elements to here and then I
define two real numbers a R equals PI
and B R equals 6 and then one
dimensional matrix real man to one
dimensional matrices kibriya type ER 1
equals Phi and BR 1 equals 6 okay
similarly in the same manner I create
two integers a int a equals 5 and 6 and
integer matrices an integer array of 10
size dimension type 1 dimensions
mattress of array of size 10 whose value
a a 1 is Phi and be a 1 is 6 similarly I
create a counterpart for logical I said
al to be true and BL to be false as
similarly I said logical one dimension
array with l1 equals true and B l1
equals false thank and now what I do is
that I am this print I'm just taking the
real numbers path
separately integer part separately and
the logical part separately and printing
the values okay now what I'm going to do
before swapping I let I'm just going to
print the value of AR be our air
wouldn't be r1 and then what they
already do is I recall the they called
the exchange subroutine I just call us
exchange subroutine with a and B are
okay with passing variables here and we
are and then I call the si exchange
operating again with this time here on
behavior so what I'm doing is that I'm
just passing two variables of the same
data type and same size into it here I'm
passing two variables same data type and
same size each of them either each of
them are one dimensional arrays of ten
ten units okay
passing them here and then I didn't do
and just getting after after these I'm
just printing the same printing the same
about after the swapping for supposedly
swapping okay I print here we are one
year one and we are okay and similarly
after this entire job is done what I'm
doing is that I'm continuing the same
process for all the integers I'm just
printing the value of integers
exchanging them here and here and then
printing the values of integers again
okay similarly I am printing the values
of logical values here and using the
exchange values over here I'm just using
the exchange function of subroutine to
exchange them and then I print them over
here
simple as that simple enough okay now
let's see how this works
logically speaking regardless of
whatever dimension you give this element
should work okay
now if I were to compile this build this
and execute this okay I'm getting a lot
of answers here let's walk through one
by one okay before swapping this is the
first part okay
yeah rs5 yes PR is sixth yes yeah one is
five and it should be a ten values okay
that doesn't matter they're ten values
over here you can count it if you want
and B are one a six six and it's ten
values again you can count it if you
want and this is okay now after swapping
yeah
six instead of fight and BRS fight store
six it's indicating that they these two
have been successfully sparked and
similarly here one is six ten times
instead of five ten times and BR one is
five ten times instead of six ten times
indicating that this also has been
swapped similarly similarly the integer
part of it which comes over here okay
which comes over here
yes which also has been swapped
accordingly here if you guys look at
this a B a and B a are five and six days
means fat barrels over here and
similarly the a1 and ba one also have
been swapped successfully and similarly
if you look at the logical part of it
yeah lists were true and BL is false and
Yale one is true and L 1 is false 10
time BL 1 nest will Falls 10 times and
they have been swapped successfully as
well now not only this not only this
even if you give something even if you
give a three-dimensional matrix or a 10
dimensional matrix it doesn't matter as
long as the entries have the same
dimension they work to just to check
whether the dimensions do cross match
okay what I am doing is that I'm
intentionally creating a mistake over
here here and be our own do not have the
same size if I were to compile this it
throws an error stating that LM stating
that on the elemental okay actual
argument that one for intended not dummy
X of elemental subroutine e^x is a
scalar but the other actual actual
argument is an array meaning what it
says is that one of them is an array one
other was a scalar so what happens is
that both of them are having is do not
have the same sizes that is what it's
complaining over here okay another hand
if I were to remove this one and if I
were to compare this it works fine and
builds fine it is on this execute this
they just work fine okay that's okay now
if you guys want to make an elemental
subroutine where in some functions is do
not care about exactly about what kind
of a teletype you have to
on the size of the data type and all
this is their best bet to work with okay
this this is a very interesting concept
and this might be a this could be a
really useful concept provided twisty of
may twist your thoughts and stuff nicely
just your thoughts such a manner for
personal application and we work or work
or very nice I just want just the I just
want you guys to know take this program
or make a copy this and you know make
your own a play with the play with the
stuff
leave the own stuff and try to see how
this works and all and this might be
very useful for you know for at least
for you know large-scale programmers and
whatever was in some models and projects
and thought okay that's all I have for
you guys in this tutorial thank you guys
for watching and I'll see you guys next
tutorial which will be I think it's the
final total of this tutor to disease and
then after that you'll have one more one
more
summary summary tutorial that somebody
says summary video lecture where we'll
be discussing on what can be done beyond
what can be done in Fortran from here
onwards thank you guys for watching and
I'll see you guys next tutorial so see
ya