Advanced Fortran Programming : 025 : User defined operators and Operator Overloading Video Lecture | Introduction to Fortran Programming (AdvancedLevel) - Database Management

hello guys my name is Aaron and welcome
to my channel this series is user
tutorials on advanced photon programming
now in this tutorial we will be looking
at an interesting concept called as
operation overloading and how to and
user defined operators now I will
explain you guys what exactly I mean by
yeah see
Fortran provides certain symbols like
the asterisk sign the addition the plus
sign and all which has some predefined
operations
you know the plus sign is used for
addition of two variables we that it may
be a it may be you know PL numbers of
floating numbers or normal numbers it
doesn't matter
and your astok symbol is for
multiplication and stuff like that each
operation each operator has their own
predefined functions predefined
operation in Fortran what operator
overloading means is that there is a
feature in Fortran wherein you can use
these symbols okay the same pretty
symbols which has a predefined operation
assigned to it to make it do some other
operation which may be similar or a
tally opposite are completely different
from what it's pre original operation is
okay now this is called less operator
overloading and then we have a look into
another console call this you say
defined operators know what exactly this
means is that just like how you define
operators like the stock like an
asterisk or the plus and all okay
Fortran gives you from we gives you
permission or use you access to create
your own type of operators operators and
define a set of jobs to it next as to
what should what it should do or not
okay now we will be going to look at
this and through and this will be a
short example but you guys should
understand you guys would understand
nicely
okay now you want to define you if you
want to make a user-defined operator or
you won't do an operator overloading
what do you need is as follows first of
all it's prayed at it's an ultimate
prerequisite okay you need an interface
block if you guys remember the previous
tutorials I will not look looking at the
interfacing options and Fortran and the
interfacing options are for trend for
subroutines and functions within the
position outside the procedure and all
okay this interface option is mandated
second you need an operating symbol yeah
that's okay the thing is you're defining
the operator so you have two different
you have to say that yeah you have to
say that the operator has a certain
value set a name to it or no that's it
and then also and more importantly okay
you need a function or a subroutine to
do the operation meaning let's say
you're doing something like a
complicated operation let's say matrix
multiplication that's it now you may
define a single operator for that okay
and you defined it but you have to tell
to the Fortran compiler that okay this
is my operator but it has to do certain
job okay now how would he give the job
it's simple what you do is just write a
function or a subroutine and somehow you
have to link it a house is linking that
the interface blocks takes takes care of
it now similarly if you have a new
operation you have if you have to do a
certain new operation and then you want
this operation to be overloaded on top
of an already existing operator who it
doesn't already exist which has an all
it's has a predefined operation set to
it like the asterisk or this plus symbol
doll what you need is again unity
interface block and you need more and
very importantly a derived data type
okay and then just like the previous
example is keys you also need a function
or a subroutine to tell the new to this
new definition of this operation as to
what to be done simple as that
now it look simple hope it I hope I
don't can't hope you are clear - yes so
far now let's look at this look at this
entire stuff using a simple program okay
what I have here is that I have I have
made a small program over here don't
worry it's long but it's very simple
trust me what I've done is that I have a
program here and it has two parts first
you have a module called as new
underscore o-p-s okay and it has an
episode none typed here and then it has
a derive data type called us SP okay and
this data data type has nothing it just
has one integer value into it called us
was okay and then I have three interface
blocks over here each of them separate
and if you guys notice unlike the
previous thing like the previous
tutorials when you're interfacing
functions we're interfacing operators
here so what you need is that you need
the special keyword called us operator
okay now once this operator key is
written inside brackets you have to
mention inside the parentheses you have
to mention as to what operator you're
using no nothing this interplays
interface block whatever do is that we
have to link a function to it or
separate into it so what I'm doing is
that I'm linking this last example with
procedure unless new underscore mod and
this new underscore model is going to a
module procedure so I'm writing this
keyword module procedure to it similarly
I am attaching a new interface operation
need to a new operation for the plus
symbol and that operation is defined by
the procedure module module procedure
new underscore ad okay and similarly the
same way and this time instead of all
that instead of already using a three
define symbol predefined operator which
already has some value to it I mean the
operation to it what I'm doing here is
that I'm creating my own operator here
now the rule for creating or operator is
this write whatever name you want but
put just put a dot on the
I mean the friend and leatherback like
to do that it becomes an operator I
remember you know some time ago we saw
that we saw that for a greater than to
less than symbols and out you have not
an option like LT GT something of that
sort
it's exactly the same what you do is
that if you have a new operator just
write the name and put a dot on the
front and at the back okay
now this way these two these in these
two say like in these lines I'm creating
interface operation for symbol sir which
already have a user defined sorry it's
already have a definition involve
invoked into it to do a certain
operation so these two are nothing but
now these operations will have a
function overloading me which our data
or how do you call it
operator overloading that if this was
not how did the operator overloading
because we're defining a new one so this
is just user defined so this is just a
user defined operator okay
now within the same module file I have
three functions over here now this
function new underscore mile will take
two variable will take two variables a
and B okay and B and we will give the
result C now if you guys notice this a
and B they are integers where then I
have they're actually integers because
this they're actually integers but these
are special type of money just called us
SP integers meaning this new singles did
a datatype type B that data type SP over
here so a and B are defined to be
defined to be divided by the type of the
data of nature SP okay signal so I'm
getting the values a and B into the
function and setting the output output
result of this function to be C which is
again of the same data type SP and what
I'm doing here is that I'm defining the
in defining the result as like this the
value of C okay
since he is just because of this data
type
she has just only one value in her which
is birth okay
the early FC value version C is actually
the product of the values of Val's in E
and B plus 3 okay so new month what will
do is that you will just if you just
pass two values to it its multiplies
these two that's three to it and then
sends it out
similarly this function new underscore
ad does more or less entirely same
process but just a dish it so what it
does is that you guys know look at is
the Santa that syntaxes are the same so
what it does here is that it just takes
two and use the values adds them and
along with it as three to it and then
sends the returns a value symplastic
just just a replicator almost a mere
application of this process okay this
way you are overloading it and here this
function is a little tricky okay
what I'm doing is that I'm if you guys
know this this dock this operated dot
okay with operation dot over here I'm
linking it with this procedure that can
be scored on the scope rod so if you
guys can figure it out it simple and if
you guys have guessed it right it is the
vector dot product of dot product of two
vectors okay so what I've done what I've
done is that I've made this function to
be a real function of kind eight okay
and it takes two vectors a and B and
gives the result DP okay now just use
the simple implicit now I'm taking the
values a and B as real values of kind 8
but dimension can be any length in
length it doesn't matter okay and then
DP is nothing but the dot product and
ASCO product of so this in turn this is
an internal function this is an internal
function its subroutine which function
which returns the dot product of a and B
so I'm using that over here but if you
guys notice I don't have to if you guys
just look at the syntax is that it on
the top on the bottom of way I stood on
the top I don't need to if you want to
define is dart right from scratch by
taking a loop and some using some is
coming
taking product of each and every set on
stuff it's perfectly possible you know
just to say you know just to show that
you know you can use already predefined
functions into it and stuff and just
including this operation over here so
yes it matter
so what is this is a DP whilst have the
dot product of the vector a and B and it
will just returned it tonight and that's
with system this module is over and
let's just look at the program the
program is named as ops it starts here
and ends here and it's very simple what
it does is that it just takes an integer
of four which is used for defining the
vectors we want to beat over here and
there it uses the new underscore ops
definitely after the margin new
underscore value so it will take it has
the type the operators and all the
function definitions inside the program
so it's been it's done it has it had
even this program runs it has the module
the interfacing options the operator
definitions the function definitions and
even the genotype everything in it ok
now this line your just is finding four
integers this line is definite four
divided by the types of type SP okay
then these two are vectors this is this
a result of dot product of thing and
look and now this is where you have to
pay little attention over here right
here I said a and B to be five and six
which is normal and EAP B is I think is
nothing but the a plus B and a and B is
ei multiplied by B naught sunglass that
M is just yet less being a star P fair
enough very simple enough okay I am
doing this there is printing the normal
operations I'm just printing well a
value B summation of a be the product of
a I'd be over here okay so this is
Alistair very simple straightforward now
here comes the overloading of overloaded
operations what I do is that I define on
the top that I defied four variables a1
b1
AP AP AP b2 am be to okay now what I do
is that I said a1 valsa in the Val value
of a1 to be 5 and the Val value FB want
to be 6 and then I'm just using a peep
- to be a 1 + be worth as a B - to be
even plus B 2 B 1 they won't start
because now you have to keep in mind one
thing we're okay I'm just using the
addition of additional addition
multiplication operation just like that
over here directly it's not even
considering but what happens is that you
have to look at the data type operation
here this data type is not an integer it
is SP the data type as we define on the
top it's it's an in deliberative SP
whereas over here this plus addition
symbol okay let me just make it a little
more easy this addition symbol and the
asterisk symbol over here these are not
these are okay operating on directly on
integers whereas these are operating on
stress divided be related types so what
happens is that in these cases the
regular operating procedure for the +4 +
for addition and multiplication have
happened that's in these cases since
these are related types SP the operate
operator or the sister the compiler we
look at the data types of realizes okay
it's not an integer it's a different
area type so it just looks into it just
looks into the definition 4 + + + +
asterisk and goes to the function goes
to this module values and C again finds
okay okay it just saw that for the
multiplication and the addition I have
to look at I have to look at the
definition of this function and this
function and then goes to here and when
it reached these Wendy when it reach
this function it does okay now this is
what I should do and it does accordingly
so that's how the compiler works this
out okay since the data types are
different it just works out differently
I mean just discern here it does not
perform normal addition supplies I mean
here it performed now original normal
multiplication here it performs our
special special edition and special
multiplication that we as we defined on
the top and then the overload of the
operations are value separated over here
okay
and similarly okay I just said we were
and we to the vectors on the top depend
on the top
okay to be all one all one and what I do
is a DP and resetting this to be v1 dot
we do intuitively we can look at this is
nothing with vector operation simple as
that now what happens is that I'm just
printing over here what it does is that
just takes B what it prints v1 v2 and
then the vector dot product DP like to
not write DP okay
simple as that now what happens here is
that when this dot when this symbol is
encountered what the photon compile does
is that it goes to all the definitions
that are available to it and then it
look it look for this then I take this
look for this operation by default this
will not be available in for time
because this is user-defined operator so
it will just go to the module to see if
there are any and it looks into the
module and finds it okay and finds this
line says okay now I have an interface
operator here so I have to okay I found
it now what it just looks at the
procedure in it to to do what happens
and now it just looks at this and then
it understood okay I got it
now I have to follow this instruction
given this procedure and then looks for
the procedure and this procedure is
found ultimately at the top yeah it is
over here
I just dust all the instructions given
in tight inside this procedure which is
nothing with the function and returns
the value out okay let us the value out
this is something it this OP how do I
put it this concept which are dealing
right now is a little bit tricky yeah
it might take a little time for you guys
to understand so what I recognize that
just run this program have a look and
then keep a fresh copy and then take you
make a copy of this and they no player
on but you know making and making your
own operator and stuff and if you guys
want if you got if you guys this want a
little more experience and practice not
experience I say you guys want a little
more of detail understanding what I
recommend is that you guys can refer to
books or any other books or any
and resources for little more likely a
clear explanation okay yeah in the case
that if you guys do not do not
understand what's going on here okay
enough of me explaining the entire stuff
let's just run this this is a simple
program let's compile this
okay dad let's compile build and okay I
think fine I just execute this too okay
there you have it
now the NAM now let's scroll and look
back enough simultaneously now the
normal operations the a is 5 B is 6
fair enough and a plus B is 11 yes
correct
fair enough and yes Tybee starting yes
perfect now let's look at the
overloading operations now loading
operations okay he ever miss five yes it
because a1 does not have a direct really
it has wild sin and so it prints okay
sorry
it has Prince a a1 on the school Evans
passed in each wall so it's Prince fight
okay we were Nebraska p1 present as well
just six okay now here's the interesting
part a plus B a a PB 2 percentage was
okay the value of walls in this their
derivative did a variable a PB 2 is 14
now how is that as per the definition
given here in this function the values
are added and then to it a three is
added so it's I plus six 11 plus 3 14
fine okay
similarly and this when these two when
the product is done what happens is that
these two values five or six are
multiplied and then two it threes will
add it so it's like pie into six pi
times 6 is 30 30 plus three 33 okay and
now you guys look at the user-defined
operation
okay the vector dot product since n is
four over here okay the vector v1 and v2
are four units long and each of the much
since the users are said to one you have
one one one
reading four times selected operations I
think with the product of these two each
and every each and every corresponding
index values of these two vectors okay
drag of these two and some summation of
all these products okay so it's because
of that you get four for the simple
answer and simple enough now this opens
if you guys notice what you can infer
here is that because of this feature
what allows you guys to do a wide
variety of operations you have the
flexibility to make your own operators
as per your choice and you know you can
use their already predefined their
operators in a way that you want you
want to do based on your data type of
okay hope you guys understood this
tutorial thank you guys for watching and
see you guys next tutorial see ya