Fortran Programming Tutorials (Revised) : 014 : Kind Attribute; Limit on Integers Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management

hello guys my name is Errol and welcome
to my channel this series is a series of
tutorials on photon programming now in
the last tutorial we saw a demonstration
of the Donna geometric progression we we
saw do loops and by doing by explaining
explaining geometry progression on how
that works on okay today we will see
about the kind operator now before we do
that I like to know exam this again and
explain that explain the kind of
phenomena that happen in the last video
I gave an initial value initial term the
value of a the initial term to be 10 and
the multiplication factor to be 10 the R
value to be 10 and I gave like 12 terms
into it okay let me just give like 13 15
terms to give a to give you guys a feel
of what exactly is going on and then
when I press ENTER what happens is that
after this particular value okay the
valleys turn to be completely random and
chaotic it's not a random and chaotic
but the coldest turn out to be
completely unpredictable it's the it's
like some it's like something is on the
program crashed or something or memory
happened memories or something or
something had to do with memory I don't
know it may be different and I have
promised the value just turned out to be
peculiarly different no this should not
happen and we suspect I suspected that
mean you guys must have been suspecting
that it might be due to a program fault
not it's not because of the program for
this because of the memory allocation
issue okay I'll explain you guys what
happens see if you guys remember if you
guys can't recall carefully wheat I told
you guys in the first one of the first
tutorials that each variable okay
whether it's an integer or a real number
or a real number or logical variable or
a character whichever it is takes a
certain needs a certain byte certain
piece of memory a certain size our
memory to you know store values now by
default integer integer takes two bytes
or four bytes or eight bytes depending
on the case to store memory and the
stores are so store the numbers and we
also saw and
you guys from the Wikipedia page okay
that okay I'll show you guys again if
you guys want to just like integers
definitions and then let's go to
Wikipedia okay
this will go up to a ring link this is
actually the mathematical integer let's
go to the integer computer science we
saw in if you guys can remember call we
saw this play we saw this page and I
told you guys to have a look at it
because it's a little important okay
there there's there is this one thing we
saw whenever the size of the bits the if
the integer store integers take a larger
memory size the larger memory says the
value they can store it gets increased
substantially now what happened now
suppose you have an 8-bit integer which
is actually a byte which is actually an
integer which takes only one byte to
store one by to store the maximum value
for an unsigned where in an integer that
that's only positive is between 0 to 255
whereas for integer that assigned the
values are minus 128 to 127 like that
and for a two bitten for you know this
is a 2 to bit to byte integer or 16-bit
integer okay the value increases to
32,000 768 and all you can see the range
increases substantially similarly for a
for a for 32 32 bits integer 32-bit
integer or a the four byte integer okay
the value increases to this big value is
close to its little above two billion
two billion whereas if we have a 64-bit
integer 64-bit integer or you know eight
bit in 8-bit into eight byte integer the
value increases to even several
manifolds like that the increase in
memory the mapper limit on the value
says the an integer can store increases
now what happens if this upper limit
gets stripped it's what is what is
happening to our program here see what
happens is if you guys just type the
value 10 the reminder 10 the initial
value down 10 the fact that
fifteen terms what happens is after this
value the upper limit for the integer of
the sudden this data type is you know is
crossed as a constant as a consequence
that limit is since that limit is
getting crossed it's not able to print
that value properly and what happens is
that when the limit is getting crossed
the entire attack number gets messed up
there when the representation see bits
integers are stored as binary binary
number binary in the combination in each
and every each and every bit okay any
anything everybody has bits and based on
the number of bits the each number is
stored as a binary combination inside
has a binary combinations so that that
combination you know if you want to know
how the combination works out of the
method that they follow to store numbers
okay
you can guys just check in wiki or you
know check for ice I Triple E standards
are as ASCII standards a CIA ASCII
standards to how look at it
it's interest it's a little interesting
it's not there are mandatory required
but it's kind of interesting to know so
that kind of value gets stripped and
then dripped okay it just crosses that
particular threshold and after that it
tries to follow the same method but it
gets confused so it it prints out like
this happens errors answer okay now one
way to solve this is because we are
getting this error because the limit is
crossed to set this to set this room it
a little different what we can do is
that there is a a parameter called us
kind okay for the dog the operator as
mentioned earlier this worker kind can
be modified now by default the kind is
actually for meaning we're defining
integers that take four bytes of memory
for storage now that being said let me
just compile a build and run this to see
whether what we did what what it is
right or wrong okay I repeat the same
values that we gave for the past two
conditions I get the same answer I get
the same answer by so by default
integers in Fortran are actually for
byte integers
okay and that kind is actually used to
indicate that these integers are these
are actually integers of by different
paths suppose there is a different
weight now if I just increase these
values to kind eight meaning now I
indicate that the integer now now I am
indicating to Fortran that these are
actually variables integer variables
that take 8 bytes of memory so it's 6
it's basically a 64-bit byte each bit
has a 64 bit byte so this can this allow
us to store a larger value so when
you're doing the multiplication process
during in the automatic progression it
will give us an even larger value now
watch I compile this build this and run
this okay I give it give it give the
same value same answers
you guys notice this time this time it
goes fairly smooth and prints everything
properly properly okay now that's the
power of another kind operation what it
does is just it helps you to store a
very large numbers it with very large
number within the same data type suppose
if I were to you know come to give a
comparison I'll use the integer
operation again let's see control shifty
yeah anyway if you guys are on a web
browser and if you happen to close a web
page okay press control shift e that
will open the lastly closely page it's a
kind of a shortcut I don't know whether
this works in incognito mode or not but
this purse really does work in Norman
board this works they got regardless of
the operating browser you use that's
kind of a handy tool for you guys to
remember now let's let's play around
with the experiment with these okay
now now if you notice the bits it's this
is a one bit integer okay this is a one
this is a one byte integer the maximum
value can store is out to the maximum
127 or 255 depending on the sign okay so
let's see where this is available so
this should be kind to okay if I compare
this yeah kind to was available so it
means this is a two by ten
run this and execute the sorry execute
this let me give you the know this time
I give you early 1 and then 2 and then
like 15 terms it crashes after it
crashes in the fifteenth term crashes at
the fifteenth term because beyond that
it's not able to store the value it's
not able to store the value and if you
guys check this in wiki for a two-bit
integer for a two-bit integer okay to
pide integer it stores a maximum of
32767 and what happens after that is
that the value gets stripped by one
hooked by one more value and it gets it
becomes a negative sign what happens is
that this is actually a signed integer
that is being used here and the LA the
fluff most digit is used for maintaining
the sign convention whether it's
positive or negative it's usually near
zero for positive and one for negative
and what happens is that when this value
reaches the peak okay that Valley gets
triggered and the sign convention
changes so the valley gets printed
properly but the sign trips sign trips
so now this being said this is the this
is how 2 by 2 bit integers work now what
we do is that let's change is kind to 4
9 to 4 now I compile this bill this and
execute this ok let me give the same
answer but instead of 15 I'll let me
give 30 terms 30 terms it's still not
crashing so let's try to crash this
intentionally so let me give like 1 2
instead of 30 I'll give you like 100
terms it should crash after some time
yeah it is crashing watch now in the
31st term
that's not you guys you know notice the
31st okay the 30th time this 10,000 1007
3 something and if you guys compare this
value the next value this is this
exactly the negative sign so this is
where it's getting tripped and if you
guys know this because of this thing the
first one is actually 2 per 1 the second
one is 2 power 2 like that and this
value is a it should be 2 power 31 to
pass 31 and that value is getting
tripped so we're getting a minus 2 power
31 which is actually this okay now they
say now this is because we store the
value in kind power 4 we store our I
know valued kind power 4 we get this
suppose if I were to give kind power 8
let's look at the 64th term assist to
see the terminal compile build and run 1
2 and then 100 terms hundred terms now
let me just compare this with wiki wiki
value I have here you guys look at the
look at the answers we get here at the
64th term the 63rd term you're getting a
fairly same answer like nine two two
three three nine two two three three
seven two seven two zero three six eight
five four seven seven five eight zero
seven but if you had look at the
negative number it's the same so we are
getting a minus two powers of c3
properly like that there is this there
is this one more kind 16 that is
available the intermediates may not be
there but the current 16 is available so
if I just compile build and run this
okay I give the same answer one two this
time this will cost 128 so I'll get me
give a value like 150 150 okay if you
guys look at the values here you guys
look at the values here
at the hundred and twenty seventh value
this one seven zero one four one one
nine three this entire digit which is
exactly the same as this so I think you
get you guys get the point okay the you
guys get the point this is how the value
of this is how this is the importance of
this kind parameter for integer and
similarly this kind parameter works in
the similar way and similarly a similar
way and for float numbers also okay and
in the next split next program and all
and you use a lot of real numbers and
out to X real numbers and all to do some
complex works we really will just no use
kind of kind variables of kind terms of
higher order to get do some to some you
know alterations or not to get the
values under proper precision and all
okay that's all I have for you guys in
this tutorial thank you guys for
watching and see you guys next time bye