Advanced Fortran Programming 009 More on Forall with Gauss Elimination

hello guys my name is Aaron and welcome
to my channel this series is a series of
tutorials on advanced Fortran
programming now in this tutorial we'll
be revisiting one of the earlier methods
we saw in the basic programming tutorial
on pressing for the photon parameter
namely the Gauss elimination method now
what we'll do is that we will do this
entire car summation method in a single
program sorry we'll do this in
comparison with for all statement okay
and we'll also look at how this can be
done using the dual loop statement and
I'll explain you guys how these two kind
of differ okay the reason why I used I
repeated this statement because is
because I want to indicate you guys one
major thing that happens and do loop
state for all statements that they have
to keep in mind while doing certain jobs
okay and now as you as usual what I did
is that the edges have to define all the
variables that you want for your entire
process I'm defining all the variables
on the top here I'm setting this to a
three by three matrix okay whose values
are less let's say let's say whose
values you know becomes whose values are
defined at the top below sorry now yes
the matrix whose values will be they
will be defining a is explicitly over
here using this reshape command and
iodine is actually identity matrix just
for you know just for this for formality
but it's not exactly required I kind of
put it but okay here I have two matrices
a B and a IB these two are the Augmented
matrix that I'll be getting by merging a
and B matrix over here simple as that
these two are just augment you know
augmented matrix matrices one matrix
will be operated using the do loop
statement whereas the other matrix will
be operated using the for all statement
to indicate a difference and
difference of how things can be paid
okay simple and then and then B B and X
are actually one actually two dimension
matrices with with n cut the end rows
and one column I could have defined this
as a one dimensional matrix but one time
symmetric one times two array but I had
to define like this because there is a
small there was some indexing issue that
came by losing certain using a certain
function at all so that doesn't matter
that doesn't matter it works and then
that a and T one that is actually the
determinant of the matrix a and T one is
actually a temporary variable would use
and T 3 is again another temporary array
but it's a one dimensional one valued
array I know you could I used with just
T 3 but I used it I will explain you
guys why and then I have them I get I
mean if if not assigning manually we can
use this function and all to get the
matters a and get the matrix B
separately in a nice nice way nothing
more and we're not using that we're
going to use over there ok and will be
if I setting the shape of a and B in
these lines using the reshape command
don't worry about the values we just
were they just print the matrix in a
proper manner we'll get the answers ok
and this function that returns the
determinant of the matrix a to this
valued at a get underscore ID and we'll
return the identity Madrid identity
match this function will return identity
matrix to the matrix I didn't get
underscore a B will return the Augmented
wanted matrix Augmented matrix of this
set a and B and to a to the matrix a B a
a I be just a replica of a be reusing
separately and using the print
underscore my two function print
underscore R 2 function what happens
matrix a the turn determinant a will be
printed here because we get the value
here okay
matrix in identity matrix will be
printed here the matrix
we'll be printed here the matrix a B
will be printed here I mean even the
other replica my augmented matrix will
be printed here and this is where the
and this is where the entire Gauss
elimination method happens now for those
of you guys I mean for those of you guys
who don't understand how this looping
mechanism works I have written a small
explanation over here now when you do a
gas elimination method what you need is
that you need or Augmented matrix okay
now this is the explanation your matrix
your coefficient matrix okay for our
castle if you express the size okay okay
let me explain this little clearly
suppose if we have a set of limit aeneas
linear equations okay let's say you have
M equations then you want to solve it
then you need M variables in these M
variables so you need M equations each
having M variables okay you know I eat
with karna connected to each other some
kind of algebra Klee such that the
right-hand side they all equal in some
linear combination of these equal to
some right hand side value now if they
have that kind of a situation what
you'll have is that the coefficient of
all this man all these values okay then
what you can do is that you can express
that set as like this as a linear
combination like this where a is a
square matrix and X is a vector
containing all the unknowns in the
column format and B is the right hand
side value is the right hand side value
simple now if you combine a and B we get
a map if sup if there are M equal m
unknowns M unknowns and M equations only
only if you have this kind of a scenario
you can go for this castle you can go
for this matrix matrix method and all
anyway and we're gonna go for Gauss
elimination if you have got M
here becomes M by M matrix of square
matrix B becomes M by 1 matrix okay
now many company and B you get an
augment matrix of order M cross M plus n
m plus 1 this M is this x is nothing but
x cross it's not an X no it's a little
hard to differentiate okay cross yeah
that I think this makes this this makes
sense okay m XS a cross so you'll get
the value like this a matrix like this
so so if you had to write them in proper
order with my eye and my index and all
okay the first index will be not the row
and the second index will ignore the
column then if you write each and every
element like every element by by its
portion and the matrix using the indices
I for row and J for column then you can
write this first element becomes a 1 1
and then a 1 to n a 1 3 and so on so
forth till the last value of a this a 1
M but since it is an awkward matrix
after this you have one more value call
this B b1 which is actually the first
element in the B matrix the first first
element in the B matrix and then
similarly you have a 2 1 a 2 2 a 2 a 2 3
and dot okay up to p2 this colon is just
for a separate and this column just for
a no separation okay and these
triple-triple dots are just to indicate
that it just goes on like that then you
have the third row fourth row fifth row
sixth row till the M throw and any M
throw it looks like this it will be like
a 1 M a M 1 M 2 M 3 where M stands for
the number of rows you have and then
finally your last value in the air
models will be a AMM and then your last
value B matrix is BN ok now what does
gas elimination method says is that is
that it goes by it goes like this
let's it goes it is the elimination
method Gore's
in rather sets okay in the first set
what you do is that you do with a linear
operation on the second row second row
using the first row in the first set
okay the first set what we do is the
you do a linear operation a linear
operation on Row 2 Row 3 Row 4 Rho Phi
up till all the M rows from second row
till the bottom row using the row 1 as a
constant constant multiplier constant
multiplier as a linear combination or
something something of that so I mean
use a linear combination with I think
it's not multiplier with linear
combination with linear combination from
from your row to use okay they ignore
the grammar here
with doing a combination a linear
combination of our row 1 ok let let let
let me name this as I equals 1 okay
simple enough then what do you do in the
second row
let's since I let me assign Jade for the
rows okay okay since we are operating on
second row let J be 2 then what will
happen to the first element is that
first element is that well if I were to
kind of do a Gauss elimination method
and reduce this to an excellent form the
first set what I'll do is that I'll just
have to subtract a to one with the
product of a 1 1 times 2 8 to 1 and
divided by a 1 1 this way I'll reduce a
a to 1 to 0 and then I have to do the
same since I added to the same linear
combination to all the values in the
same row all the values in the same row
what I do using the corresponding
corresponding element positions and
column Row 1 ok
a 2 2 becomes a 2 2 minus a 1 2 instead
of a 1 1 here it's a 1 2 times a 2 1
there divided by a 1 1 like that and
this is a 2 3 equals a 2 3 minus a 1 3 D
multiplied by 8 to 1 divided by a 1 1
now if you guys notice here where we are
operating on the second row first column
so let me keep kf4 column so I have K
equals 1 and then here second row second
column
equals two okay third columns of K
equals three so on and so forth till I
get the last column to scale equals M
and finally there are K plus 1 columns
it will be actually the which is
actually the B matrix where we'll be
operating the B matrix here b2 will if
you follow the same convention over the
top b2 will be actually equal to b2
minus b1 because b1 is the element that
is located in the first row
corresponding to the same same column in
the column index to the same column
index a set of b1 so it's B 1 B 2 B 2 so
B 1 and a 2 1 there be a 1 1 and so on
now with this set up with this set of
with this with this set 8:2 a 2 is the
Row 2 is reduced now if we do a repeat
this set with a 3 will have our
equations will slightly modify okay and
then the multiplication factor becomes a
2 a 3 1 0 a 1 1 all right like that and
this is continue until the last row that
J equals M ok once this is done this
entire process is repeated with the
second row with the second with the
second the second set in the second set
what happens is that you instead of
start in the second set we use with with
linear combination from Row 2 used ok
the sec in the second set what we do is
that we start the job from J equals 3 or
its Row 3 because your first row is
already done we first row first row we
don't modify the first row at all
second row is reduced okay and then now
using the second row as a reference or
aurélia come as a linear combination
input we only have to modify Row 3 Row 4
over Rho Phi and all the rows subsequent
to it using that way so
so that way and then that is done the K
should be varying from 2 to M plus 1
because the the element 8 to 1 will all
for a three one would have would have
been zero during this kind of an
elimination process if you guys notice
because of this recurrent recurring
pattern over here all the elements in
the first column X all the elements in
the first column except a11 will be
right it will be 0 it will be 0 because
of this elimination and in this second
set we have to start the K in the
elimination from K equals 2 or the
second column all the way till M plus 1
skål them okay in the third in the
fourth set like in the same set but in
the fourth row it should give and go
from k plus 2 to n plus 1 like that and
so on now with this being done this Dad
process has to be repeated for to
compete second set and then third said
okay I it's just it's starts on y equals
3 y equals 3 J starts from 4 J starts
from 4 to M plus 1 M plus 1 M plus 1 and
the case case K starts from you know
three to three to implement something
like that sorry ok like that and so like
that and so forth like that if you guys
notice there will be like M mind there
will be like several sets of this form
okay now if you guys notice a pattern
from this and if you use I J and K kind
of Matthias Lee and properly what you'll
get is that you'll get a pattern similar
to this pattern over here you'll get
this pattern over here okay this is what
we'll get now if we compare the kind of
path if you just look if you just look
at the indices and everything nicely
okay for any condition for these any
condition for these your eye for your
case will be varying from 2 sorry 1 1 to
M minus 1 and your j will be varying
okay
you guys notice in this process J starts
1 value more than I in any place okay
so J starts from I plus 1 till young
till M okay and your K will start from
your I value because if you notice in
this equation your K starts with the
same value as that of I and goes till M
plus 1 so these are the three in the end
these are the ranges of K IJ k and the
same radius of i j k are used instead of
um i'm using n over here but anyway it's
exactly the same okay and one more thing
is that and this process if you guys
notice it will be AI b j comma k equals
AI b j comma K minus minus AI be I comma
J sorry it's AI comma K star star AI B
now what will this be what will this be
J comma AI J comma I okay
divided divided by your EI i be i comma
i and you and them here to end all the
loops you just send them here so this is
what this is the pattern you get if you
guys look at the ijk ijk notions
properly but there is one point you have
to keep in mind when you do this Gauss
elimination if you guys look at this
equation over here they're using a 2 1 a
2 1 and we're modifying a 2 1 over here
and because we're using the same 8 to 1
value we're copying the a 2 and value
and modifying it to give a new do you
update the value of a 2 1 but in this
next equation when you use a 2 1 ok
instead of the previous value only the
old value remains so what you have to do
you have to assign this previous value
to loop which does not with to a value
and use that within the entire of the
loop entire of this K loop so what I did
is that I just saved T with this AI be J
comma I which is which which that part
is actually class when did it come a
comma J comma I and they used that okay
and I we used that value over here so
that during the repetition process okay
the the value J comma I is actually say
used it till the end of the program kind
of till the end of this loop properly
that's the reason so this is kind of the
extremely optimized hopefully the
extremely optimized version of the Gauss
elimination method okay
now if you want to do this kind of a
process okay in far loop what people
might have initially think that you know
I'll do the same job over here and since
we saw that the matrix system get
modified until otherwise the entire loop
is done like this okay
let me comment this out this is this
but I looking coming this odd for a
while okay let me come on this out for a
while
okay now wait okay the instead of
writing three loops like this let me
write something of this sort okay let me
write something of this side and proceed
with it now people might think that this
since the memory retention is not an
issue over here okay
the memory memory issues is not a
problem over and loop we can write this
entire stuff in a single compressed
format like this agreed but there's a
problem of there's a problem over here
if I were to compile this what happens
is that you get a warning first warning
it says that the for all with index I is
not as is not be used on the right-hand
side statement so it's indicating that
there are multiple assignments to J
comma K that can happen in the entire
process well it's just a warning but
it's okay that's a warning it's not a
better at least to work it and their
work and then it's saying an error that
your for all index I should not may not
appear on the triplets specification
what it's saying is that if you are
using a variable in the for out
statement like I okay you cannot use
this in the same for all again okay and
similarly because of the same thing you
cannot use I over here now how do we
know because of that this 3/8 nest 3
level ester code is not available for us
available for us so this is turning out
to be an error not to solve this what
happens is what what happens is that
what can we do
is that write them in nested format the
same thing the nested format okay
without having this not having this
temporary variable we'll write the same
thing in the nested format okay
nested format okay now if we were to run
this sorry if you were to compile this
it just shows a warning that we have
reduced eye in the eye on the
right-hand-side assignment and it's
saying that matrix might have multiple
assignment issues and all okay but it
doesn't matter but it actually doesn't
matter by the way okay now if I were to
give you guys a hint of what exactly is
going on what exactly going on okay this
is the column this after this loop the
column gets modified accordingly what
happened to this yeah
the column gets modified accordingly so
I will give a step-by-step explanation
of how things are okay now to explain
the memory memory memory saving stuff
and all let's print the matrix here
instead of after little bit let me write
this as during the matrix during process
here again writing like doing process
okay
now this should not throw me in error or
anything okay and yeah yeah you are not
allowed to call either you guys noticed
this is one more stuff you are not
allowed to call subroutines inside for
all statements like this okay these are
some of the things you have to keep in
mind so because of this thing you cannot
use for all statements you cannot use
subroutines or other call statements it
says inside do loop in this for all
things okay because because of a memory
data event internship retention stuff
returns in the stuff yeah if you were to
call a subroutine here to do the print
to print the entire matrix at its
current stage it will not allow me on
the other hand do loop acts were more or
less independently and being so because
of it if I were to print this during the
it won't it won't cost me any issue so
if I were to run this okay I've had to
run this what I did I just written a
shell script I'm removing all the object
files modify text video files here I'm
compiling the module file first the the
second the Gaza the application file
next and then getting the objects and
run executing building a executable here
and then executing the executing it here
now because of the nice features Genie
since I have a shell script here I don't
go to the terminal and run I just have
to press f5 simple as that
now it's just printing a lot of
mattresses at the top it even prints the
warning that happens but that's okay but
it's okay it's not a problem
it prints matrix a the dumped of a the
identity miles I say ok the matrix B the
matrix a B the matrix a I be okay before
processing and Mattocks AIB during
process if you guys notice this is after
the elimination of the sec this is after
the Gauss elimination of the second row
using the first row okay and this is the
Gauss elimination this is the Gauss
elimination now after third row using
the first row and then we go to the new
process wherein we will be eliminating
the third row will do it will be doing
the oscillation of the third row using
the second row and after that since the
number of rows have been reached number
of rows has been hit okay the ghazal
mission stops otherwise it'll be just
going on and on and on like that okay
finally the Mattocks AIB after being
processed is like this that is that
matrix a B which was processed by the
same which we do we've done the same job
as that of the Gauss elimination okay
using the for all statement is like this
you guys notice it's hardly any
difference it's hardly any difference
simple as that simple as that and your
solution is like this which is turning
out to be correct just turning out to be
card I just take this and I kind of you
know work this out suffer
and there are a lot of solutions on the
internet I checked them out and it
worked out to be fine okay this is how a
ghazal this is one of the day this is a
Gauss elimination application works and
this is how you know you have to use for
all statements although these are one of
the places where and you if you were to
conserve your matrix you have to save
your matrix they keep it intact from a
previous value or to have new updated
value and all for all statement is
extremely useful and big and you can do
that's one thing and if you were to use
a nested for out statement like this you
cannot use the say you cannot use the
the the you know the end or in the
trading variable that are already
available here in the same line for
other I trace other I traitors okay and
you cannot call subroutines or certain
print functions within the for all
statement or dolls okay so these are
things you have to keep in mind while
doing this hope you guys learned
something in this tutorial well I did I
did find myself I found my this tutorial
it'll interesting and hope and hopefully
I guess you guys understood how this
Gossard nation method has been put in
the previous tutorial light I kind of
you know ignore the fact to explain the
previous to the ignore the fact to
explain the gas generation Gauss
elimination method especially the
beginners tutorial because I didn't want
that time I didn't want people you guys
to know can't get confused just wanted
to you know explain demonstrate you guys
as to how looping spur done so but do
you guys must be you know little
advanced enough right now so that I
thought you know you might will
understand how this goes by this is kind
of the alga this is kind of the pseudo
Karaka this is kind of the algorithm
that works by paper I actually wrote
this in a piece of paper and then I kind
of you know worked it out the stuff I
just repeated replicated there in the
text so that I can explain you guys as
to what happens this is how from this is
how you get that is algorithm or a
pseudocode ready once you get something
like this ready transferring it to
corner and getting the chorus just just
a matter of time
simple as that okay thank you guys for
watching and see you guys next tutorial
and I hope you guys learned something
new today and this is and this is how
you have to use a for-loop and law by