Fortran Programming Complete Course

Learn how to write simple programs to compute compound interest, mastering coding rules and a logical problem-solving plan, while seeing how compilation and execution use RAM, variables, and memory locations.

Explore the Fortran program layout, covering compulsory statements, program structure, line usage, blanks, continuation with ampersands, and exclamation-mark comments for readability.

Explore Fortran data types, including five intrinsic types: integer, real, complex, character, and logical, and the role of kinds. Also learn about derived data types with their values and operations.

Explore how literal constants define integer and real values, including binary, octal, and hexadecimal forms, and distinguish fixed-point and floating-point representations with exponent notation.

Explore how names and variables are defined in Fortran, including valid identifiers, initialization, and the importance of meaningful, case-sensitive names while avoiding implicit typing errors.

Learn to compute the vertical displacement in vertical motion under gravity, using initial speed and time to find s, with gravity G and no resistance, via a simple Fortran program.

Explore Fortran programming style to improve readability by detailing well laid out logic, clear comments, alphabetical declarations, initialization conventions, spaced operators, and blank lines separating program parts.

Explore numeric expressions in Fortran by combining constants and variables with intrinsic operators, learn unary and binary operators, operator precedence, and how integer division truncates toward zero.

Explore numerical assignment in Fortran, where the equals sign means becomes; assign expressions to variables, handle type conversion, avoid unintended integer division, and cast to real when averaging marks.

Explore Fortran input and output using read and print, detailing data transfer, input records, unit numbers, external files, and basic formatting for displaying data.

The section explains how the compiler translates Fortran statements into machine code and covers intrinsic data types, literals, declaration rules, and input output with print and read.

Explore do loops in Fortran, mastering iteration, input/output prompts, and simple algorithms like Newton's method for square roots, with practical examples such as compound interest projects.

Explore if-then-else decisions in Fortran to compute a student's final mark from external file data and exam scores, with conditional branches and a 50 percent pass threshold.

The lecture explains the intrinsic character type in Fortran, including literal constants, apostrophes and delimiters, string length, and declaring character variables, with examples of reading and printing names.

Explore named constants in Fortran, using the parameter attribute to declare immutable values, initialize expressions at compile time, and observe syntax rules for intrinsic operators and double colon usage.

Explore the concept of kind in Fortran, including default kinds, kind parameters for integers and reals, the selected kind function, and portable, type-safe declarations.

Explore how complex numbers are handled in Fortran 90, including complex constants and how many intrinsic functions accept complex arguments.

Explore intrinsic or built-in functions in Fortran to compute projectile motion, including horizontal and vertical displacements, velocity components, and angle conversions between degrees and radians.

Master the do loop to repeat statements and use the if-then-else construct. Recognize character constants in quotes or apostrophes, named constants, and the kind type system with complex numbers.

Break down real problems into fundamental logical states and develop a systematic algorithm for solving them. Follow charts and structure plans outlined earlier to guide algorithm development.

Explore how flowcharts visualize algorithms, using a Fahrenheit to Celsius conversion as an example, and learn the main flowchart symbols, conditions, and do loop concepts in Fortran programming.

Explore an alternative method of program preparation using multi-level structure plans that increase complexity as the logical structure develops, illustrated with Fahrenheit to Celsius conversion and a quadratic equation.

Explore structuring advanced programs with procedures and subroutines, where a self-contained code section communicates with the main program and can be invoked as a first level structure plan.

Apply a systematic, logical method to solve problems before coding in Fortran, using flow charts and structure plans to diagram algorithms and outline tasks, and invoke procedures when needed.

Discover how computers' quick arithmetic and their ability to make decisions fuel great problem-solving power, and how the Fortran case construct supports fundamental decision making and repeating statements.

Master the Fortran if construct by exploring simple and nested if statements, the use of else and else if, and efficient evaluation within do loops.

Explore the Fortran logical type, including true and false values and default kind. See how logical expressions use relational and logical operators, with series and parallel logic analogies.

Use the case construct to select among cases based on a selector value, applicable to integer, character, or logical types, often replacing long if chains.

Examine the damage caused by indiscriminate use of the goto statement in Fortran and basic, contrast with structured languages like Pascal, and highlight its label-based form and the spaghetti-code risk.

Explore conditional execution in the if construct and case construct in Fortran, including nesting, logical expressions with relational operators, true/false values, and bit manipulation on integers.

Explore the do construct in Fortran programming to repeat statements, distinguishing deterministic repetition from non-deterministic repetition where the end condition materializes during the loop.

Explore deterministic repetition in fortran do loops, early termination, and sequence convergence, and study transfer function like responses to varying inputs in computational iterations.

Explore the general form of the do construct in Fortran, with two variables and a max-based iteration count that governs the loop, including zero-to-count and duration rules.

Handle non-integer increments in loops to manage iteration counts and align outputs with exact time intervals despite rounding errors. Explore spacing-based methods to avoid missed intervals and ensure deterministic prints.

Use nested do loops to print a table of loan repayments for a 1000-dollar loan over 15, 20, and 25 years at interest rates from 10 to 20 percent.

Fortran programming complete course teaches non-deterministic loops, exploring do loops with end-of-loop exits, random number generation, seeds, and clear structure plans for loop termination.

Explains an age-structured gnus population model in Kruger, using a four-age vector and birth, survival, and lion predation parameters to predict next year's population.

Section 6 introduces do constructs for deterministic and non-deterministic loops in Fortran, covering repeat-until, do while, and exit conditions, with notes on naming and iteration parameters.

Identify bugs and practice debugging, and examine the four error types—logic errors and rounding errors among them—that can arise in the programs we've written.

Identify ordinary errors, fatal errors, and warnings in the Fortran compiler, understand how it reports issues, and learn examples like missing if statements and undeclared variables.

Learn to diagnose run-time errors that crash programs, such as division by zero and overflow, and explore Fortran 90 facilities for intercepting and handling these errors.

Identify and fix errors in the logic of your Fortran programs by testing with known cases, tracing the code by hand, and using debugging tools to locate wrong results.

Explore how rounding error arises from finite computer precision and learn to reduce it by testing true real expressions, using higher precision, and rearranging calculations for numerical stability.

Identify syntax, execution, and input/output errors that may be intercepted at wrong times, and use debugging tools to trace statements, fix logical errors, and understand rounding due to finite precision.

Discover how Fortran 90 enables tasks to be implemented as functions and subroutines, organized in libraries and modules, with internal and external program units; examples include sorting and differential equations.

Explore internal subprograms in Fortran, focusing on functions and subroutines, argument passing with dummy and actual arguments, and the role of global and local variables.

Define the main program required for Fortran programs and explain how internal programs execute only when invoked by a color statement or by referencing its name for a function.

Explore how external subprograms reside in separate files to be accessible by many programs. Compare external and internal subprograms, noting that external ones are self-contained and linked, not decompiled.

Explore how Fortran 90 uses explicit interface blocks to define subprogram interfaces, contrasting with implicit interfaces for external subprogram calls, and cover overloading and generic naming.

Explore how Fortran modules organize main programs, external subprograms, and modules themselves, with shared declarations and interfaces accessible via use statements and private or public controls.

Explore how the scope of a label or name in Fortran is defined by main, internal, and external program units, from the program statement to its end.

Explore how Fortran passes actual arguments to subprograms by reference or by value, including variables, arrays, and substrings, and how intent and optional arguments (including keywords) prevent errors.

Fortran 90 overloading uses a generic name defined by an interface to call different specific subroutines for real, integer, or complex arguments.

Plan large programs by using stops to define subprogram names, then fill and compile after each step to catch compiler errors early, moving local variables out to avoid full recompile.

Explore recursion by defining factorial recursively, showing direct and indirect self-calls, and the memory and time costs. Learn how a recursive subroutine implements quicksort and contrast with non-recursive versions.

Breaks down large Fortran programs into internal and external subprograms, modules, and libraries, using calls, arguments, and explicit interfaces.

Learn to use subscripted variables and arrays in Fortran to manage large data sets, analyze numbers or names, and solve systems of linear equations with powerful array features.

Compute the sample mean and standard deviation for the end observations in Fortran. Read data into an array and obtain a mean of 5.76 and a standard deviation of 2.53.

Define and manipulate Fortran arrays, understand size, elements, and subscripts, recognize default lower bound of one, support two dimensional arrays and shapes, and use array constructors and implied do loops.

Pass arrays as subprogram arguments using assumed shape and explicit interfaces to compute statistics like mean and standard deviation in subroutines.

Learn how allocatable dynamic arrays in Fortran manage unknown data sizes by allocating and deallocating memory at runtime, using one-dimensional and relocatable arrays for efficient memory use.

Master Fortran programming by exploring a chapter five program that finds the student with the highest mark using an array of top names. It shows top-name memory saving concepts.

Explore the bubble sort algorithm for sorting a list into ascending order, using multiple passes to swap out-of-order elements, with notes on efficiency and comparison to quicksort.

Quicksort uses divide and conquer to sort lists by partitioning around a pivot. Left side holds values less than the pivot, right side holds greater values, and recursion sorts each.

Explore Fortran 90's powerful array features for numerical analysis, including one-dimensional constant arrays, array constructors, slices, implied do loops, and array broadcasting.

Fortran section covers arrays as data structures for large datasets, detailing elements, size, bounds, and up to seven dimensions; it covers passing arrays, dummy shapes, allocable memory, and elementwise operations.

Learn to use format specifications to produce meter output and master data transfer involving files, expanding from prior program-solving practice.

Model rabbit population with Fibonacci-like growth in Fortran, starting from a newborn pair, maturing after two months, updating three variables monthly without arrays, and formatting output for twelve months.

Learn the form of the Fortran print statement, including how expressions and variables are used, and how a list of quantities can be used in the same way as read.

Explore Fortran's formatting features, including edit descriptors for fixed and scientific notation, field widths, signs, and tabulation, to control input and output precision and layout.

Explore formatted read in Fortran, handling input from files, managing i/o units, and gracefully intercepting errors or end-of-file conditions while using standard input and output units.

Explain the formatted write construct in Fortran, using specifiers identical to the read statement, and show how to select output devices at runtime to print large data efficiently.

Explore how internal files convert numeric data to strings and strings to numbers, enabling read and write operations and supporting graphical display captions.

Learn how to manage external files in Fortran, including sequential and direct access with formatted or unformatted records, opened by unit numbers, and closed correctly.

Explore non-advancing i/o in Fortran, leaving files at the current record and reading individual characters, including a program that counts characters in a text file and handles end-of-file versus end-of-record.

Explore Fortran input and output concepts, including data lists, named groups, and repeat counts, with guidance on delimiters, character constants, and complex values.

Explore how fortran handles input and output, including file opening, unit numbers, and record formats, with guidance on sequential and direct access and end-of-file handling.