Database Management Exam > Database Management Videos > Introduction to Fortran Programming (Basic Level) > Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions
Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
FAQs on Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions Video Lecture - Introduction to Fortran Programming (Basic Level) - Database Management
| 1. How can I calculate the determinant of a matrix using subroutines and functions in Fortran programming? |  |
Ans. To calculate the determinant of a matrix using subroutines and functions in Fortran programming, you can follow these steps:
1. Define a subroutine or function that takes the matrix as input.
2. Implement the logic to calculate the determinant within the subroutine or function.
3. Use appropriate loops and mathematical operations to perform the calculations.
4. Return the determinant as the output of the subroutine or function.
Here is an example code snippet to calculate the determinant of a matrix using subroutines and functions in Fortran:
```fortran
subroutine calculate_determinant(matrix, n, det)
real :: matrix(n,n)
integer :: n
real :: det
! Implementation of determinant calculation logic goes here
end subroutine
```
You can then call this subroutine from your main program, passing the matrix and its size as arguments.
| 2. Can I use existing Fortran libraries or modules to calculate the determinant of a matrix? | |
Ans. Yes, you can use existing Fortran libraries or modules to calculate the determinant of a matrix. Fortran provides various libraries and modules that offer mathematical functions, including determinant calculation. One such popular library is LAPACK (Linear Algebra Package), which provides highly optimized routines for various linear algebra operations, including matrix determinants. You can use the LAPACK library by linking it to your Fortran program and calling the appropriate LAPACK functions to calculate the determinant.
| 3. What is the advantage of using subroutines and functions to calculate the determinant? | |
Ans. Using subroutines and functions to calculate the determinant of a matrix offers several advantages:
1. Reusability: Once you have implemented the subroutine or function for determinant calculation, you can easily reuse it in multiple parts of your code or in different programs without having to rewrite the logic.
2. Modularity: By encapsulating the determinant calculation logic within a subroutine or function, you improve the modularity of your code. This makes it easier to understand, maintain, and debug.
3. Code organization: Using subroutines and functions allows you to organize your code into smaller, manageable chunks, making it more readable and structured.
4. Encapsulation: Subroutines and functions provide a way to encapsulate the determinant calculation logic, hiding the implementation details from the main program. This helps in focusing on the high-level logic and promotes code abstraction.
| 4. Are there any limitations or considerations to keep in mind while calculating determinants using subroutines and functions in Fortran? | |
Ans. While calculating determinants using subroutines and functions in Fortran, there are a few limitations and considerations to keep in mind:
1. Matrix size: The implementation of determinant calculation should handle matrices of different sizes. Make sure to consider the appropriate size limitations based on the available memory and computational resources.
2. Performance: Depending on the complexity of the algorithm used for determinant calculation, the performance of the subroutine or function may vary. Consider using efficient algorithms or optimized libraries for better performance.
3. Numerical stability: Determinant calculation can be numerically unstable, especially for large matrices or matrices with ill-conditioned elements. Be aware of potential numerical issues and consider using appropriate techniques to enhance numerical stability, such as pivoting or matrix conditioning.
4. Error handling: It is important to handle error conditions, such as singular matrices (zero determinant) or invalid input, in your subroutine or function. Implement proper error handling mechanisms to provide meaningful feedback to the user.
| 5. Can I calculate the determinant of a non-square matrix using the provided subroutines and functions? | |
Ans. No, the provided subroutines and functions are designed to calculate the determinant of square matrices. Determinant is defined only for square matrices, where the number of rows is equal to the number of columns. If you try to calculate the determinant of a non-square matrix using these subroutines and functions, it may lead to incorrect results or errors. It is important to ensure that the matrix you provide as input is a square matrix before performing determinant calculations.
Text Transcript from Video
hello guys my name is Erin welcome to my
channel
this series is a series of tutorials on
photon programming now in the last
tutorial we were working on this program
and we were trying to calculate they
were trying to find the sliced matrix
and slice of a matrix using the mask
feature available and the reshape
reshape and path features available but
at the same time we also looked at how
to print the matrix and the standard
matrix kind of format that is in the
standard Mattox kind of format and we
also looked at the column based memory
allocation features of Fortran now in
this tutorial this will be an extension
of this since some features that we
learned over here especially the write
write with advanced no feature the
c-shaped back and slicing okay we'll be
using this in our program this program I
mean in this tutorial we'll be looking
to find the determinant of a program
without determinant of a matrix yeah
using the feature that we learned up
learned before and this will include the
usage of subroutines and the functions
now what I have here is I have a problem
called as deter it will goes from here
and here and ends here and then you have
a to have a recursive function trail
function and then a subroutine okay
I'll explain you guys how this works as
you go along okay now what now if you if
you guys messed up now must be knowing
determinant of a matrix is actually some
is actually the product of the product
of the first element of each row
something of that some broad some of the
prior to the first element of each row
times the matrix the other matrix which
does not have the row and the column of
that element and going going on I know
that's kind of a lame way to look at I
think but you guys will and will
understand and we go along
hard to write that what I've done what
I've done is that I have
incident statement and then I defined a
parameter and which equals three
now what this will do it will set the
shape and I have the matrix accordingly
says say she I mean shape of the matrix
accordingly now this being constant it
kind of like statically allocates the
memory for the matrix okay and now this
is the matrix and for which the
determinant has to be found and it's
damaged it's a real matrix type of kind
aid and it's a size n comma n since n is
3 here is 3 comma 3 here now if you just
want to change it we can just if you
want to change the value of n just
change the value here and that will be
done and then what I am going to finding
here I'm defining a real variable of
type kind aid and it's external now
since this is external this will be
nothing but a function so this is a
function that will be using DET f and
then the dot F and then I'm going to
defining away valued that every kind 8
and real number this is the determinant
and different to integers I comma J now
what I did is that just like using the
same program same function methodology
that we adopted here I'm defining five
matrices by different values of matrix
okay one of them will have this value
other will have this value like that at
all I'm just commented that out
I also written the different determinant
values might determine values of these
mattresses
okay as of now I'm allocating this
answer this value to the matrix mat okay
okay now this is where I'm calling this
is where I'm calling the federal
external function that tough to find a
determinant this determinant this
function will return at the determinant
and you have to little her as a
parameters it will have two values
namely that it and that will be the
matrix and the order in okay
and now this will do all the calculation
and this is just a printing statement
that we kind of used here okay I'm just
going to print the matrix and the proper
matrix like format over here okay this
line will print the each and every value
of the row row and then this will help
this will just give a new line break so
that the other matrix can the other row
of the matrix can be written accordingly
and then I predict the determinant here
now let's look at the real function here
this is let's look at this real function
which in terms of matrix returns the
determinant okay for this this I'm
defining this to be a recursive function
okay now this function is recursive and
it does of type eight okay and the term
this is the term determinant I mean this
is the function definition this is the
function if that data and it takes two
arguments matrix matrix a matrix of name
m-matt and it's size n okay and this
will give us a result that writing this
separately because this is recursive and
I don't want to make it complete to make
it same I leave confusing so I'm but I'm
going to set the did well resolve
various dead okay inside what we have is
that I have an implicit none statement
I'm getting the value of n inside and
this this will be defined as an integer
and its intent in so that this value is
coming inside a function and it will not
change throughout the operation of the
function okay and now I'd if similarly
using this value of n I define the
matrix Matt that will coming in and just
like on the top this is a real real late
and it's dimension income and then I'm
setting here I'm just adding one more
the attribute called as intend in so
that this matrix again remains
untampered
okay and then I'm defining a new matrix
here which is for the calculation
purposes okay this is of type eight and
real and it's this dimensions are for
this this is these are like one row and
one column less then this done that this
math and given matrix and this now this
is nothing but the slice sliced matrix
that will be going to use all right now
now I'm setting this initial and here
again here I am set
I just wanted a variable I just wanted
it is a variable I so I'm setting I here
okay
and now and initially to cast our
calculator to start the calculation I am
setting the determinant value to be zero
determinant value to be zero
all right and the determinant value to
be zero and if now I now this is the
loop that that this is a loop that does
all the job now if the determinant of
the matrix means the order of the matrix
is to the determinant will be the
product of the diagonal elements in the
one in a 2 comma 2 matrix the product
the determinant will be the product of
these diagonal elements subtracted by
the product of the anti diagonal
elements and it idled elements so this
is will be a simple case and okay sup I
forgot to add one more statement else if
suppose if somebody enters a 1
dimensional matrix let's say then that
the determinant will be equal to Matt 1
comma 1 that's it and that is it and I'm
using return value here okay
I'm using a return value here so that
what this happens is that this this
arithmetic will be calculated and it
will be stored in this value and then
nasan when this value hits this value is
calculated it'll just end the function
and return this value whenever it is
called now suppose somebody enters a
matrix of size n which will not fit in
this category all I have to do is that I
have to use this function alright all I
have to do is that use this else--if
else--if and that will take care of it
will take care of it okay and now you
know we'll be experimenting with these
two and then finally now if somebody
enters a matrix of size 3 or greater
than 3 then we need us we need it as
arithmetic to do that so now that will
be
they can this they care of taking care
of in this l statement or to do is that
it starts a do loop from I value 1 to n
and every time of and every time it
calls it calls the subroutine called a
slice F and it will it will it will take
the value SL mat n + 1 and I okay well
okay now the determinant and this will
I'll explain the function how this works
okay now this this line the determinant
will be equal to the previous sum it had
plus -1 power minus 1 raised to the
power raised to the sum of the row index
and the column index is ax is nothing
but the column index here okay I'm using
the I'm expanding the determinant using
the first row you can you can expand the
determine using any row of your choice
but I'm using the first row here so that
doesn't matter I am using the first row
so and expand first row sum of the I'd
mix of the first row and column here and
then tie this power times the matrix
well the matrix value or the matrix
value at the first row and the index I
and the 8th column with this earth
column product and that is multiplied by
the determinant of the matrix which have
which need which does not have this the
in take the index I the first the first
row first row and the corresponding
column and in consideration okay now if
you guys look at the determinants of
determinants when you are trying to
expand it all you need is the cofactor
matrix now that co-fighter matters is
actually is given I mean no I think it's
a it's a minor because this -1 power x
takes care of the cofactor ratio so this
matrix will actually return the minor
minor of the minor of the matrix of
further given index other given index
this suppose if your row is 1 under
consideration a column is 1 okay this
matrix will
return will just remove the first row
and the first column of that matrix and
return the remaining under it and return
the remaining portion in the form of SL
and that will be that will be passed in
four kind of hiding determinant and this
function will call the will call itself
again and we'll proceed further okay and
now it will recursively call until it
hits these one of these two statements
and then comes out and then similarly
this looping will continue and to do
this slice F okay to get the valley SL
I'm calling a subroutine call s slice F
now this slice of is nothing but the
implementation of this slicing operation
we done here in a simplified manner this
is it what I've done is that I've
written a shard subroutine called a
slice F it'll have a it it will have the
five parameters passed by arguments
passed into it I have an implicit none
implicit none and it had three integers
whose values I'm taking in okay those
values are n the order of the matrix the
row that has to be sliced out and the
column that has to be sliced out and
then I have a real real mad matrix of
size n a real square matrix of size n
okay of type eight of kind eight and
it's I'm reading the value inside that
that is mat okay that is mat and then
what I'm going to do is that I'm going
to define a matrix SL I mean I'm going
to get I'm going to define this matrix
SL whose size will be one row and one
column less than this matrix and I'm
defining this matrix with the key with
the parameter in 10th out meaning this
value will be the output value that will
be coming out going out meaning in it
will not come with any predefined value
so this this ability will alter the
value of this function will this
variable and that will be going out and
then just like in the previous program I
define the logical matrix of dimension n
comma n I named it mask okay now I set
all the value of mass to be true and
then just like the just let this
statement over here
I am setting the resetting the road to
be false and the corresponding column
that has to be mass to be false and now
that's like using this operation over
here okay I am removing I'm just taking
on I'm just masking all the valleys that
are not available that are not available
as per this and using the pac function
and using this up using this shape
operation i am shaping this matrix
together shaping this metals to the
required shape to the required one and
thus therefore I'm getting a sliced
matrix out and this matrix will be used
here all right now now if you guys did
not understand this I recommend you guys
just watch this video again and
parallely while you guys do this do it
take a piece of paper and I mean I
recommend you take a piece of paper and
you know work this out or think little
carefully you will get the logic you'll
get the logic nicely okay actually I
thought of inorder writing the recording
this and explaining this simultaneously
but this Court took me some time to the
time to do and when it recorded and it
just took a lot of time okay so I
thought have no writing this and
explaining us how this works okay now
this being said all I have to do is this
compile build and execute this there you
have it this is the matrix okay I'll
keep it here okay this is the matrix
here as of now and it printed out the
matrix nicely and the determinant is 1
okay now let's change the determinant
okay now let's change the matrix now let
me put this here I compile build and
execute this yeah perfect for this
matrix okay the determinant is minus 306
and it printed out - 306 very nicely
okay similarly let's take another matrix
this matrix okay this is by far a
singular matrix meaning it does not have
determinant if I were to run this there
you have it the determinant is 0
similarly if you guys want you can run
then you can activate any other mattress
matrix and do it it will work out the
same and by the way I defined this for a
3 3 cross 3 matrix suppose if you guys
wanted to cross flow matrix even then it
will work all you have to do is change
the value here and the odds for some
facility here to enter the value at the
mattresses and here done you're good to
go and then let's check this out
ok my father to comment all this ok now
what I do is then instead of this else
if I decide it says if this I think this
should work fine this should work fine
okay let me add one of these mattresses
into picture this should be minus three
not six okay yeah perfect should it is
giving three not 6-3 not six so are you
gonna do is it even this is not
necessary this is not necessary because
of the slicing algorithm we slicing the
subroutine you're done here this will
work just fine this will work yes just
fine all right now that's now that's all
I have for you guys in this tutorial
hope you guys understood how this how
this works and this is a really nice X
this is a really nice programming
experience for me hope you guys had some
interesting thing to do here also hope
you guys found something interesting in
this tutorial ok thanks guys for
watching the next tutorial we will be
looking at we will be looking at a
little wheel working at another way we
will be using this determinant and this
subroutine this determinant function
sorry
and this subroutine function to catch it
and we will be using this for another
application which will become which will
be which will be very much useful and
this will make a lot of sense this will
make a lot of sense in a longer lotta
longer purpose ok thank you guys for
watching see you guys next arrow then
bye
channel
this series is a series of tutorials on
photon programming now in the last
tutorial we were working on this program
and we were trying to calculate they
were trying to find the sliced matrix
and slice of a matrix using the mask
feature available and the reshape
reshape and path features available but
at the same time we also looked at how
to print the matrix and the standard
matrix kind of format that is in the
standard Mattox kind of format and we
also looked at the column based memory
allocation features of Fortran now in
this tutorial this will be an extension
of this since some features that we
learned over here especially the write
write with advanced no feature the
c-shaped back and slicing okay we'll be
using this in our program this program I
mean in this tutorial we'll be looking
to find the determinant of a program
without determinant of a matrix yeah
using the feature that we learned up
learned before and this will include the
usage of subroutines and the functions
now what I have here is I have a problem
called as deter it will goes from here
and here and ends here and then you have
a to have a recursive function trail
function and then a subroutine okay
I'll explain you guys how this works as
you go along okay now what now if you if
you guys messed up now must be knowing
determinant of a matrix is actually some
is actually the product of the product
of the first element of each row
something of that some broad some of the
prior to the first element of each row
times the matrix the other matrix which
does not have the row and the column of
that element and going going on I know
that's kind of a lame way to look at I
think but you guys will and will
understand and we go along
hard to write that what I've done what
I've done is that I have
incident statement and then I defined a
parameter and which equals three
now what this will do it will set the
shape and I have the matrix accordingly
says say she I mean shape of the matrix
accordingly now this being constant it
kind of like statically allocates the
memory for the matrix okay and now this
is the matrix and for which the
determinant has to be found and it's
damaged it's a real matrix type of kind
aid and it's a size n comma n since n is
3 here is 3 comma 3 here now if you just
want to change it we can just if you
want to change the value of n just
change the value here and that will be
done and then what I am going to finding
here I'm defining a real variable of
type kind aid and it's external now
since this is external this will be
nothing but a function so this is a
function that will be using DET f and
then the dot F and then I'm going to
defining away valued that every kind 8
and real number this is the determinant
and different to integers I comma J now
what I did is that just like using the
same program same function methodology
that we adopted here I'm defining five
matrices by different values of matrix
okay one of them will have this value
other will have this value like that at
all I'm just commented that out
I also written the different determinant
values might determine values of these
mattresses
okay as of now I'm allocating this
answer this value to the matrix mat okay
okay now this is where I'm calling this
is where I'm calling the federal
external function that tough to find a
determinant this determinant this
function will return at the determinant
and you have to little her as a
parameters it will have two values
namely that it and that will be the
matrix and the order in okay
and now this will do all the calculation
and this is just a printing statement
that we kind of used here okay I'm just
going to print the matrix and the proper
matrix like format over here okay this
line will print the each and every value
of the row row and then this will help
this will just give a new line break so
that the other matrix can the other row
of the matrix can be written accordingly
and then I predict the determinant here
now let's look at the real function here
this is let's look at this real function
which in terms of matrix returns the
determinant okay for this this I'm
defining this to be a recursive function
okay now this function is recursive and
it does of type eight okay and the term
this is the term determinant I mean this
is the function definition this is the
function if that data and it takes two
arguments matrix matrix a matrix of name
m-matt and it's size n okay and this
will give us a result that writing this
separately because this is recursive and
I don't want to make it complete to make
it same I leave confusing so I'm but I'm
going to set the did well resolve
various dead okay inside what we have is
that I have an implicit none statement
I'm getting the value of n inside and
this this will be defined as an integer
and its intent in so that this value is
coming inside a function and it will not
change throughout the operation of the
function okay and now I'd if similarly
using this value of n I define the
matrix Matt that will coming in and just
like on the top this is a real real late
and it's dimension income and then I'm
setting here I'm just adding one more
the attribute called as intend in so
that this matrix again remains
untampered
okay and then I'm defining a new matrix
here which is for the calculation
purposes okay this is of type eight and
real and it's this dimensions are for
this this is these are like one row and
one column less then this done that this
math and given matrix and this now this
is nothing but the slice sliced matrix
that will be going to use all right now
now I'm setting this initial and here
again here I am set
I just wanted a variable I just wanted
it is a variable I so I'm setting I here
okay
and now and initially to cast our
calculator to start the calculation I am
setting the determinant value to be zero
determinant value to be zero
all right and the determinant value to
be zero and if now I now this is the
loop that that this is a loop that does
all the job now if the determinant of
the matrix means the order of the matrix
is to the determinant will be the
product of the diagonal elements in the
one in a 2 comma 2 matrix the product
the determinant will be the product of
these diagonal elements subtracted by
the product of the anti diagonal
elements and it idled elements so this
is will be a simple case and okay sup I
forgot to add one more statement else if
suppose if somebody enters a 1
dimensional matrix let's say then that
the determinant will be equal to Matt 1
comma 1 that's it and that is it and I'm
using return value here okay
I'm using a return value here so that
what this happens is that this this
arithmetic will be calculated and it
will be stored in this value and then
nasan when this value hits this value is
calculated it'll just end the function
and return this value whenever it is
called now suppose somebody enters a
matrix of size n which will not fit in
this category all I have to do is that I
have to use this function alright all I
have to do is that use this else--if
else--if and that will take care of it
will take care of it okay and now you
know we'll be experimenting with these
two and then finally now if somebody
enters a matrix of size 3 or greater
than 3 then we need us we need it as
arithmetic to do that so now that will
be
they can this they care of taking care
of in this l statement or to do is that
it starts a do loop from I value 1 to n
and every time of and every time it
calls it calls the subroutine called a
slice F and it will it will it will take
the value SL mat n + 1 and I okay well
okay now the determinant and this will
I'll explain the function how this works
okay now this this line the determinant
will be equal to the previous sum it had
plus -1 power minus 1 raised to the
power raised to the sum of the row index
and the column index is ax is nothing
but the column index here okay I'm using
the I'm expanding the determinant using
the first row you can you can expand the
determine using any row of your choice
but I'm using the first row here so that
doesn't matter I am using the first row
so and expand first row sum of the I'd
mix of the first row and column here and
then tie this power times the matrix
well the matrix value or the matrix
value at the first row and the index I
and the 8th column with this earth
column product and that is multiplied by
the determinant of the matrix which have
which need which does not have this the
in take the index I the first the first
row first row and the corresponding
column and in consideration okay now if
you guys look at the determinants of
determinants when you are trying to
expand it all you need is the cofactor
matrix now that co-fighter matters is
actually is given I mean no I think it's
a it's a minor because this -1 power x
takes care of the cofactor ratio so this
matrix will actually return the minor
minor of the minor of the matrix of
further given index other given index
this suppose if your row is 1 under
consideration a column is 1 okay this
matrix will
return will just remove the first row
and the first column of that matrix and
return the remaining under it and return
the remaining portion in the form of SL
and that will be that will be passed in
four kind of hiding determinant and this
function will call the will call itself
again and we'll proceed further okay and
now it will recursively call until it
hits these one of these two statements
and then comes out and then similarly
this looping will continue and to do
this slice F okay to get the valley SL
I'm calling a subroutine call s slice F
now this slice of is nothing but the
implementation of this slicing operation
we done here in a simplified manner this
is it what I've done is that I've
written a shard subroutine called a
slice F it'll have a it it will have the
five parameters passed by arguments
passed into it I have an implicit none
implicit none and it had three integers
whose values I'm taking in okay those
values are n the order of the matrix the
row that has to be sliced out and the
column that has to be sliced out and
then I have a real real mad matrix of
size n a real square matrix of size n
okay of type eight of kind eight and
it's I'm reading the value inside that
that is mat okay that is mat and then
what I'm going to do is that I'm going
to define a matrix SL I mean I'm going
to get I'm going to define this matrix
SL whose size will be one row and one
column less than this matrix and I'm
defining this matrix with the key with
the parameter in 10th out meaning this
value will be the output value that will
be coming out going out meaning in it
will not come with any predefined value
so this this ability will alter the
value of this function will this
variable and that will be going out and
then just like in the previous program I
define the logical matrix of dimension n
comma n I named it mask okay now I set
all the value of mass to be true and
then just like the just let this
statement over here
I am setting the resetting the road to
be false and the corresponding column
that has to be mass to be false and now
that's like using this operation over
here okay I am removing I'm just taking
on I'm just masking all the valleys that
are not available that are not available
as per this and using the pac function
and using this up using this shape
operation i am shaping this matrix
together shaping this metals to the
required shape to the required one and
thus therefore I'm getting a sliced
matrix out and this matrix will be used
here all right now now if you guys did
not understand this I recommend you guys
just watch this video again and
parallely while you guys do this do it
take a piece of paper and I mean I
recommend you take a piece of paper and
you know work this out or think little
carefully you will get the logic you'll
get the logic nicely okay actually I
thought of inorder writing the recording
this and explaining this simultaneously
but this Court took me some time to the
time to do and when it recorded and it
just took a lot of time okay so I
thought have no writing this and
explaining us how this works okay now
this being said all I have to do is this
compile build and execute this there you
have it this is the matrix okay I'll
keep it here okay this is the matrix
here as of now and it printed out the
matrix nicely and the determinant is 1
okay now let's change the determinant
okay now let's change the matrix now let
me put this here I compile build and
execute this yeah perfect for this
matrix okay the determinant is minus 306
and it printed out - 306 very nicely
okay similarly let's take another matrix
this matrix okay this is by far a
singular matrix meaning it does not have
determinant if I were to run this there
you have it the determinant is 0
similarly if you guys want you can run
then you can activate any other mattress
matrix and do it it will work out the
same and by the way I defined this for a
3 3 cross 3 matrix suppose if you guys
wanted to cross flow matrix even then it
will work all you have to do is change
the value here and the odds for some
facility here to enter the value at the
mattresses and here done you're good to
go and then let's check this out
ok my father to comment all this ok now
what I do is then instead of this else
if I decide it says if this I think this
should work fine this should work fine
okay let me add one of these mattresses
into picture this should be minus three
not six okay yeah perfect should it is
giving three not 6-3 not six so are you
gonna do is it even this is not
necessary this is not necessary because
of the slicing algorithm we slicing the
subroutine you're done here this will
work just fine this will work yes just
fine all right now that's now that's all
I have for you guys in this tutorial
hope you guys understood how this how
this works and this is a really nice X
this is a really nice programming
experience for me hope you guys had some
interesting thing to do here also hope
you guys found something interesting in
this tutorial ok thanks guys for
watching the next tutorial we will be
looking at we will be looking at a
little wheel working at another way we
will be using this determinant and this
subroutine this determinant function
sorry
and this subroutine function to catch it
and we will be using this for another
application which will become which will
be which will be very much useful and
this will make a lot of sense this will
make a lot of sense in a longer lotta
longer purpose ok thank you guys for
watching see you guys next arrow then
bye
Related Exams
About this Video
|
4.86/5 Rating |
|
Nov 24, 2024 Last updated |
Video Description: Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions for Database Management 2024 is part of Introduction to Fortran Programming (Basic Level) preparation.
The notes and questions for Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions have been prepared according to the Database Management exam syllabus.
Information about Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions covers all important topics for Database Management 2024 Exam.
Find important definitions, questions, notes, meanings, examples, exercises and tests below for Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions.
Introduction of Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions in English is available as part of our Introduction to Fortran Programming (Basic Level) for Database Management & Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions in
Hindi for Introduction to Fortran Programming (Basic Level) course. Download more important topics related with notes, lectures and mock test series for
Database Management Exam by signing up for free.
Description
Video Lecture & Questions for Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management - Database Management full syllabus preparation | Free video for Database Management exam to prepare for Introduction to Fortran Programming (Basic Level).
Information about Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions
Here you can find the meaning of Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions defined & explained in the simplest way possible.
Besides explaining types of Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions theory, EduRev gives you an ample number of questions to practice Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions tests,
examples and also practice Database Management tests.
|
Explore Courses for Database Management exam
|
|
Signup for Free!
Signup to see your scores go up within 7 days! Learn & Practice with 1000+ FREE Notes, Videos & Tests.
Related Searches
Semester Notes
,past year papers
,video lectures
,Objective type Questions
,Important questions
,shortcuts and tricks
,Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
,MCQs
,ppt
,mock tests for examination
,Exam
,practice quizzes
,study material
,Previous Year Questions with Solutions
,Free
,Viva Questions
,Extra Questions
,Sample Paper
,Summary
,Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
,Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions Video Lecture | Introduction to Fortran Programming (Basic Level) - Database Management
;
Study Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions on the App
Students of Database Management can study Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions alongwith tests & analysis from the EduRev app,
which will help them while preparing for their exam. Apart from the Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions,
students can also utilize the EduRev App for other study materials such as previous year question papers, syllabus, important questions, etc.
The EduRev App will make your learning easier as you can access it from anywhere you want.
The content of Fortran Programming Tutorials (Revised) : 038 : Determinant Using Subroutines and Functions is prepared as per the latest Database Management syllabus.
|
© EduRev
|
Education Revolution
|
Follow Us
|
Signup to see your scores
go up within 7 days!
Access 1000+ FREE Docs, Videos and Tests
Takes less than 10 seconds to signup