Fortran Programming Tutorials (Revised) 024 Formats; Arrays; allocate;

hello guys my name is Aaron and welcome
to my channel this is a series of
tutorials on Fortran programming now in
the last tutorials we saw about some
farmer specifications meant for read and
print statements now I like to continue
on that I just not much but just one
more topic which I forgot to add in that
tutorial it's regarding the cat farmer
specifications for characters okay now
suppose you have a character like this
and if you want to read and write them
okay what you can do is that is that you
can go for read statement and instead of
nahma formatting like this you can go
you can write some formatting like this
what does this mean
sorry and Casey okay what does this mean
is that J stands for the format for
names or strings and this for T
represents the number of characters you
are allowing allowing to is the string
to have you know since this is just a
character variable it will a fought it
will just take only one and forty will
not be necessary on the other hand if
you just give a character name like ten
okay now the guy two into ten this means
this becomes a string which can take ten
characters up at the maximum so this is
how it goes okay now let's see now if
you had to print this what you can do is
that print in the format you only can do
is just type a 10 comma AC now if I just
hold on sorry I forgot you have to close
this
in paranthesis also compiled this no
other bill this no other and I execute
this now you have to look carefully very
well since since I don't put any print
statements of five comma minus five
point to come fourteen point five six
and it stills waiting because now in
this line the read statement is waiting
at here start to give a name something
like okay QWERTY okay as it symbolize
that okay now this is actually the
specification for Strings and now based
on the string names okay you can adjust
accordingly
and this goes oh then this goes fine
also
now what no this goes fine I'm just
adding it here for you guys to know have
a look
eight ten something okay now a stands
for character string
then number of spaces in the field as
simple as that
okay now with that they're closing
formats and but I have to give you guys
a little information there are these are
not the only format specifiers available
in Fortran there are a little more
complicated Fortran Pharma specifiers
which serve a bigger purpose but we will
not be dealing with that under a and for
most of the practical applications this
these formatting will be sufficient okay
but if you guys really wanted even more
complicated expressions or formatting
and you can always refer you can always
refer books or Google it up or reference
reference manuals okay that that that
that is purely based on your thoughts it
is needs and besides so these farmers
specifiers have some descriptors also
which tend to you know make a little
modification which men tend to make a
little modifications sort of stuff I do
a little logical writing and all the
logical reading and writing and all okay
so this is optional but if you guys want
to know about it
you can have a look but I doubt that I
doubt the doubt that you guys will need
it on a very serious practical basis but
on as always if you guys need it how you
guys need it you can always go ahead and
have a look on your own okay now let's
let's do close this up let's have a new
file save it and now in my folders in my
photon for tutorials I create a new
folder called as arrays finally a back
into arrays and I'm going to save this
in the name array array s dot F 95
okay now this program program is to
demonstrate use of ice okay I won't say
the usual virus now what we'll do is
that in this program we use cat will if
I try to find the Fibonacci series for
the numbers okay
and now as I am out update this in the
program demands to the use of arrays by
finding the Fibonacci series
okay I think I haven't enabled this up
in the top and then will this and
interdiction yes places yeah very nice
using Fibonacci series you know there
are multiple examples I'm just going
with a simple one so that you guys
understand so program third beret okay
and program third buddy okay and these
are trading spaces we don't need
implicit none okay since this is a
series we he actually do not need to you
actually do not need to know need
required real numbers here because
seminar series is integer series so we
don't need real numbers so what do i do
is that i just create an integer integer
okay and then to make sure this is a
time this is a series what I do is that
I create I enter a value keyword that we
used in the strings to mixing arrays now
call us dimension and inside it let me
inside it I am keeping it blank okay and
keeping it blank
No so let me make this as 10 to start
with and I say this as fib all right
okay flip valves okay and then I need to
I need two integers I need to win - I
need an integer called us let's see I
mean I just need why I just need one
integer for some looping statement I
call it I and this is this is all I need
for a Fibonacci series and now there are
multiple ways to calculate Fibonacci
series the one with the array is
extremely simple extremely simple I'll
explain you guys how now what you do is
that v buzz open the value and I click
click click make it the first and first
value of it to be one and then okay and
then I put the Val's 2 equals 1 again
okay
okay I'll just click pick make this as
one okay and now now I just start a do
loop do I equals let's see 3 2 3 2 say
yes I need one more okay and I just
start a print statement print and to use
the format I let's make recreate a
format
okay and I just need n okay fine
formality okay
and the number of values number of CDs
CDs okay enter the number of values in
Philip Bourne C series to be displayed
okay now this will show pop up another
okay so what I do is that I just type
yeah kind here and then I what I do here
is that I write the format specifier I
mean I will not be using more than ten
so I to us you know let me just click I
3 I 3 sufficient okay in this do loop I
already do is I just end it here okay
what I do is that it's simple tip was of
I okay equals fib
well of I minus one plus tip wells of I
minus two as simple as that now to print
it print it what I do is that friend
with I use another do loop do I equals 1
to n and do print
friend I don't need any comment here the
okay I'll use a format and use a comma a
comma shape well I
okay here the farmer die loses then now
you the format here then format format
the
the Fibonacci value comma i3 the term
expresses is us base and then I type I
that this may be big so I'll just type I
fight this look okay now if I were to
compile this and it's getting a warning
here it's not another word son okay what
I do what I have to do is that suppose
if you I might have told you guys in the
earlier tutorial but anyway this in mind
thing suppose if your line is too long
and if you want to write display the
line or fight the line income in
multiple statements okay
whatever do is that put an and statement
and put an under statement and the last
and then write the start the next line
with the same on statements sometimes in
the previous versions of Fortran all you
do is that put this on statement and you
don't mean you'd have to need this to
continue sometimes in the newer versions
is you don't need you don't actually
need this but sometimes we just throw
throw a little warning okay but it's
like well it's work but it's a good
practice to use it and sometimes so if
now I compile this again it's highly an
error suppose not only an statement can
be used sometimes any other statement
can be used but the provide I provided
okay the same statement is it's not like
that
thing it it has to be in and because I
heard in some place I heard from one
source I think I might be wrong I heard
from some source that you have to use
and and yeah it can use any symbol okay
I think it's probably and because I
understand more common used anyway this
has to be done now what now what I just
walk you through the code we define at
the maximum ten ten valued integer
integer variable so it's an array
tib-fib underscore values a unit is an
array integer Eric having ten values
into it 10 integers into it and we did
find two more integers i and then now
sorry
we need a print I need a read statement
here you know what I do I said I read is
a value n from the user and the format
with which I read is given by this
formatic statement so I do not expect as
I know it will not be - I'll enter a
value less than 10 at the maximum 10
here so that this dimension meets me
meet with me then what I do is I just
define these two values initially the
first value of the Fibonacci first value
of the second value array and from the
third value on whatever do is that I
just start the loop with do loop with I
equals three and we'll do go all the way
to learn for each earlier Phi this fifth
value of I will be the sum of the
previous two values so if it's 3 this
will be fib 2 plus step 1 but for
there's a tip for v 3 first clip 2 and
that's it and so on so this way yeah
this loop will calculate and once all of
this is calculated the wheel the this
loop statement loop statement will print
the print and the values of I and in v
underscore valves of ie in this formal
so it will be like the Fibonacci value
of 5 the terminal value 5 is this the
Fibonacci value okay okay okay like I
mean Fibonacci value of 6 this this like
something of that sort so if we compare
this with this yeah instead of you know
doing the shortcut key element terminal
let me just do this in the terminal
itself
now we're and let's go back one level if
I just click LS there are there is this
folder colors array is a go it sorry
erase I go there or you can see these
files what I do is that just remove
these like this
like to start oh okay now what I do
instead of doing a two-step compilation
procedure to get your executable as per
your name there's another way to do that
what do you do is there's a step G for
trend and then type file and then what
you do you just type this o - o flag the
power flag and then type this is a race
yeah and then type this fib dot exe okay
new click enter it works fine nothing
pops up but actually this Eric this
executable gets created so if i just
type fib TXE okay and click enter
there's a problem here at line at line
turn it at lahat line
let's see a constant string in input
format okay okay sorry sorry I forgot
this cannot be used because you know
this can this cannot be used because you
know you cannot pass printing statements
here so I kind of just missed it messed
it out now I let's see I just make this
as print print
okay I just printed fast you know I just
pinned it at the end that will be fine
okay now I just read this okay I'll just
speed this fight okay yeah this will
look so if I just know how to compile
this again if I were to do this file it
won't show me anything if I just enter a
value like right it'll print the little
printer okay
no if I were to run this again okay I'll
just raise the screen up a little yeah
if I run this value for up to ten it
will print all the way all the thickness
value from one to ten okay
suppose if ever if ever takes do this
for 15 it will throw me another watch so
funny
it didn't throw sometimes you know
sometimes an allocations kind of a jest
but if I were to be a little ambitious
and if I put something like two sorry to
be ambitious and put something like 2003
feminazis can get two minutes too messy
afterwards let me put something like 25
yeah you get this issue you get this
something called a segmentation fault
because because if you see this array is
only designed to hold ten continuous
memory allocations see an integer can
hold integer the whole two bytes because
of this dimension it holds this value
holds 20 bytes of memory 20 bytes of
memory so I can hold ten values
sometimes as a backup as a little backup
what the program that word the fibonacci
sorry what the arrays do and the
compiler does is that allocates it saves
a little more memory just in case if
values go out of control
or yes to know do some processing
afterwards okay but what segmentation
for what segmentation fault is that it
comes whenever a certain memory certain
memory which is not allowed for the
program to program or variable to access
gets accessed in the process since it's
ten okay
I'll just do this again if I just give
ten at the maximum it's still within the
limit but if I do this with fifteen okay
only up to ten is within the limit but
but this value eleven twelve thirteen
fourteen fifteen they are not within the
limits of underscore valves array but
they are little like a buffer buffer
memory kept for the compiler you know in
case if it needs a little more values
afterwards okay but if you go something
like 20 sorry if I go or something like
20 it show segmentation fault but it
still proceeds a little more to give an
answer but if I were to go like hundred
this will blow up this will blow up
because you guys notice after this the
formatting goes out of control but it's
still it's still it's trying its best to
do some do something about it yeah but
because of this format thing these
values are getting starred okay so let
me just make that correction over here
well if I just make this as I 10 8 10 or
something let's try let's try this again
sorry let's try this again yeah exe I
give something like 100 again watch yeah
it's perfect this is what I meant this
is what I meant for this is what I mean
okay you see up to 46 it's working fine
but after that look at the memory I look
at the values of the Fibonacci series
they turn into negative that it does not
mean the Fibonacci series is
terminations cannot turn negative but
it's its values are negative why is that
it's because it's trying to access
memory location
that is not available to the the do loop
and this fill valve three binders call
Val sorry they are trying to access both
of them are trying to access valleys
that are not available not available on
within the dumb regime of its memory and
because of its it's trying to access
some memory which is not in it and that
value might have some junk value or
answers or garbage and the stored during
the previous during a previous operation
processors and all which they have
another have been cleaned and then those
valleys get used up used up the results
get corrupted and this is Gail Kirkland
you you can you come up with this
completely random and not at all lop off
plausible answers so at the maximum all
I can say is this this is the limit up
to which four or less the this the
memory location allocated for the
program is working beyond that the
buffer memory is lost and then whenever
it tries to do that it is accesses
memory that is beyond the gallic beyond
its allocation and somehow the program
is proceeding but this does gives a
warning that some invalid memory
reference has been made called a
segmentation fault and it's going some
way in telling some issues and that the
core is dumped and all okay this is
something I have to work with erase and
now suppose I know that I cannot be just
contented with no sometimes you might
know that I just kept only ten but this
may not work so how can I work how can I
know rectify this
sometimes what you can do me I'll
explain this again see by this program
by defining this dimension to be ten
okay
I'm setting a limit on the array but
sometimes you know that the setting a
limit might not work you might need a
condition where you have to go for like
100 variables a thousand variables or
ten thousand variables sand continuously
you know there are some function by the
way there are certain programs where and
you need that much of memory maybe for
simple things you may not know
but there are a few programs for which
we need that so what I do is that to
make that possible
type a colon okay in front of it type a
keyword allocate put allocatable what
does this mean is that this calls calls
for a concept called as dynamic memory
allocation see whenever in all this time
in all the total US visa all the
variables get a certain piece of memory
allocated to them in a static manner
meaning why the comparison execution
self done or the comparison building
it's done the codes in the machine codes
and the compiling compiler I mean in the
object files and the executable files
allocate a certain pincer ton bit of
memory before doing all the processes
freehand now what does this allocatable
statement does is that it gives a little
leverage to allocate the memory during
the execution during the execution so
that it fits it fits the context prop it
fits our need properly so by the by
default you see the compiled programs
are faster because you're able to
allocate the memory and allocate the
memory beforehand and do a lot of
processes by optimizing the machine code
but this allocation process is makes us
easy but it makes the job easy for us
but it makes the job a little difficult
for the compeller because it has to give
some it has to you know remove some
optimization processes to make sure the
allocation happens so it's allocation
process or dynamic memory allocation
becomes a little little slower but it
works works a lot I mean it it becomes
it becomes really helpful now how do we
allocate that it's because it's like
this now as in when I get the value n
what I do is allocate allocate now fib
underscore was okay and then inside the
bracket I put in okay and then and then
that data set and then at the end of the
program
okay if I want to remove this allocation
all I have to do is that B have to type
a keyword allocate deallocate and then
the array symbols and that's it
now what this does this I decide to
comment over here allocates n times
integer n integers an integer to the
array at run time Advantech okay as
simple as that
yeah I simple as that
okay and here what it does this D
allocate the allocates the array as
simple as that
now if I were to try this up let's see I
have to try this out if I just you know
try this up I just have to execute this
again once this execution is done if I
give early like 50 watch still going
negative okay but but at least it's not
showing any segmentation fault and all
okay now let's I think this is because
of the formatting stuff okay now let me
change the formatting a little more to
accommodate this stuff let me make this
15 let me make this 15 have had to
compile this again and they're gonna
execute this the same valley 50 it works
fine but still going negative hmm
possibly big okay I will just compile
this again close this again and execute
this give 50 the same repetition
but there is no segmentation fault error
here
this is segmentation fault errors here
so I'll just let you guys know I
seriously don't know why this turn
becomes negative so even the here oh
yeah okay now I get it now I get it
see I think the I think the reason why
we are getting negative here this is
attributed to through is attributed to
reasons okay it's added to only one
reason in the previous time this became
negative possibly because possibly
because of lack of memory allocation
lack of memory allocation due to segment
fault issues and because and because of
and because and because of you know the
because of limits of integers see what I
mean what I mean is see an integer with
only two bytes by default of occupies
two bytes of memory and there's an upper
hand upper limit on the number of values
the number of value know the upper limit
on the values and integer can store so
for instance we just go to week google
okay i'll show you guys what this means
that's that integers integers integers
integer numbers into the definition
let's see we keep let's go to Wikipedia
I think that I think Ricky will have a
proper documentation of it do this 30
times over here okay
in compute let's say whether there are
some computer explanations of it yeah in
computers and we need this one
we need this one yeah because this goes
for mathematical integers and this goes
for computer integers okay now you guys
notice there are several types if you
guys go through this entire stuff there
are you know you don't have to go
through everything but there are some
rules and regulations as to how many
values how many values
and I mean how much the numbers can be
stored in an integer in mostly there are
two types of integers like a signed and
unsigned integers okay if there are n
bytes or n bits the number of values
number of values by its can store
depends on that number the max upper
limit on the number can be stored as it
depends on that so these are some
representations of the different types
of numbers can be stored the different
limits of numbers can be stored for
instance if they're if there's a if
there's a integer that holds only four
bits literally that means half a bite
half a bite then if it's a signed number
signed integer meaning then they take
from negative and positive values the
limit ranges from minus eight to seven
it's given by this notation to power 3
minus 2 power 3 to 2 power 3 minus 1
okay it Atomics and if if it is unsigned
he can store between 0 to 2 15 which is
gained with 2 power 4 minus 1 0 to 2
power 4 minus 1 the upper limit is to
perform something of that sort
okay and if it's one byte integer which
which has 8 bits eight bits the values
it the unsigned values you can store us
minus 128 to 127 whereas if it's
unsigned where and all the numbers are
positive the value comes to us from 0 to
255 whereas if it's a 16-bit 16 but a
16-bit integer meaning a to binary
integer or a normal integer some time
okay the valley you can store is this
much from minus 32,768 to 32,767 given
by this age to raise to minus 2 or a
stoop 15 to 2 raised to 15 minus 1 or if
it's unsigned this value and most of our
integers we use are 32-bit meaning where
the integers occupies 4 bytes and this
is the limit we have on them pause and
then our program
in our program if you guys notice this
has one two three four five six seven
eight nine ten ten digits ten digits and
if you look at our value here at 46 yeah
already from three and this make this
course like another three six and this
is ten there are 10 digits when you add
up these two definite the sum was
approximately 29,000 something okay is
approximately now from here is to nine
something then about 10 digits and the
limit we we see here is approximately
let's see two billion one hundred forty
seven million four hundred eighty three
thousand six seven forty that's the
limit we have here it's so the limit
limit is approximately two billion and
147 million but in our answer if you
look at this is the sum of these two
xlvii Fibonacci number will be where
will be more than this limit it will be
2 billion 49 2 billion 96 mil 97
millions 97 million nine hundred seventy
million something and so on so that
limit is getting crossed here so this is
an example and after seeing this erase
you know to make this a little more easy
what you can do is that you can use this
kind variable kind statement that we saw
at the back at long long of when the
first programs okay we can make this
eight now if I were to make this eight
now the limit gets pushed even harder
now it becomes a four byte integer but
it gets a four bit integer and can take
up values between minus 2 power 63 - to
pass 53 minus 1 so and afterwards even
there are even there are even more
longer ones available but for our
particle uplink purpose this is this
rapid efficient now watch this if I save
this run this now I mean the executable
is ready now what I do is that I gave
the same 50 watch now it's not showing
and is proceeding further and still
there are a lot of values if I just give
up to like hundred watch it's going out
of control because of formatting okay I
know I have to change the formatting
here okay say let's say I keep it like
25 hopefully hopefully that limit does
not crash okay now they do that I gave
100 again yeah yeah unfortunately after
the 90 second value even this is
crashing even this is crashing because
of this negative sign we don't have any
segmentation fault errors but these are
purely because of segmentation faults
like these are purely because of you
know the limits getting crushed nothing
more and if you guys want to know why
yeah add addition of these two becomes
negative negative it's because the limit
is crossed and the weight which there
are ways in which the numbers get stored
and numbers get stored in the computer
using ANSI formats and all those formats
explain you guys has to why numbers gets
to Nebraska store and all practically
means each number is stored as some kind
of me I'll give a simple former simple
explanation each number is stored as a
binary in a binary value in which the
last the first the leftmost digit this
is important for maintaining the sign
convention now when the when the when
these two numbers add up what happened
is the the sign convention the binary
when they used two binary numbers add up
the last the leftmost digit also gets an
increment when that value gets
incremented
that gets incremented what happens is
that the sign the sign flips simple as
that the sign flips so if let's say 0 is
for positive and one is for negative
then when these two numbers are added
that sign also gets flipped up and big
and then because of it you get a
negative negative value and there is
this funny me this reminds me of a joke
not a joke a serious incident okay
why did Google YouTube YouTube change
the the view view okay okay let me take
a second why the YouTube change the
number for number of views number number
of views type you know this site
explaining this yeah
there's this funny thing size Gong si
you know this this is in Korra Psy's
Gangnam style videos views counter well
I mean counter and YouTube was actually
this much see they have a lot in go to
youtube the number of like number of
views is actually maintained by is
actually maintained by a variable it's
an integer variable that stores not the
maximum this much because it's made up
of a 32-bit integer or four byte integer
as we saw in our program but thing is
after the site the Psy's Gangnam said
video was so popular that the the peak
limit of the number of views got hit got
hit and because of which after that
after that what happened what happened
what happened is that after every view
after this that the value became
negative well they actually did not
become a negative but they gave a lot of
X this I mean this person have answered
it properly and the thing is that to
make sure that this does not happen the
the views actually became negative to
make sure that this negative does not
happen they have to reset the the
integer integer type for that value if
you guys want more answers you know
there are a lot of people to explain who
have explained a lot here you
you can just have a look at it okay and
there are you know a lot of explanations
here and all kind of kind of have to the
same thing I mean what we is noticed in
our program is similar to what happened
to this that video
no it just causes a little bit and if
you want the even these values to be
printed we have to you know change this
limit to 16 hope hopefully the hopefully
there is a value that takes care of it
let's see oh it works I have to give you
like 100 oh yeah thank God 16 is just
too big 16 is just too big that they
just worked fine okay 16 is just too big
it'll just work fine enough in that case
now this is this way you got it you got
an idea of how different kinds of values
can be stored and into different integer
types that are available and the
available and Fortran see each of these
type like the one that stores to the
husk that that's that takes two into two
bytes of memory the four bytes of memory
eight bytes of the 16 bytes of memory
and all each of their own name
some call it shortened long end the long
long and are very long in something like
that that depends on different
programming languages okay the
convention different programming
languages all you have to know is that
regardless of the naming convention if
the it's better to know how much types
how much integer bytes of memory can
each integer can store and also that you
can accommodate your storing processes
accordingly nothing more that'll be a
brainy really good health and and more
and moreover you also serve with the
dynamic allocation of allocation using
this allocatable statement and this free
statement and this erich87 deallocate
statement and we also look for found we
also got to know the limits of the
number of the digits at limits are the
highest upper limit the limits of the
marry that can be stored
by integers and thankfully that it's a
good thing to you just Fibonacci series
because it we are able to no crosses
ever supposed you have to go for
geometric series that limit will be too
much then you have to you know change
this value again and again to fit a lot
and we don't we cannot go for a lot
larger range but this is good enough for
us to have a look at okay now with this
I conclude this video thank you guys for
watching hope you guys learned something
interesting out of it in the next
tutorial we look at a little more thing
little more things in detail about Irish
and I will explain you guys up with some
other indexing features are available
arrays and we'll go into
multi-dimensional arrays and column
ranking method and after this we will
definitely will in the next setup tutor
next set of videos will be the following
some array operations I mean the inbuilt
using some intrinsic functions that are
available in Fortran and Fortran and
then finally and then finally the we
will go into the major topic functions
and subroutines okay once you guys get
to know about sub function subroutines
you know you are you would have been
very comfortable enough to do a large
amount of computations on your own okay
and after that whatever you after that
you know learning more the more practice
mean okay let me refresh this after
learning some functions and subroutines
there is just one more topic called as
modules and that module topic will be
will be like helpful for you you guys to
do a lot of job and then afterwards we
will be looking at a little more
examples and and I will explain you guys
a little more concepts that may not be
necessary on the immediate area for the
immediate purpose but it will be useful
as you go along for complex operations
so once again thank you guys for
watching and see you guys in the next
time