Fundamentals of Fortran 90 by ltj39095

VIEWS: 0 PAGES: 41

									Fundamentals of Fortran 90


      Basic Building Blocks
 Identifiers

An identifier is a name that a programmer creates
for items within a program including: variables,
constants, and subprograms.




                                                    2
Rules for Identifiers

1   The first character must be a letter.
2   The remaining characters may be letters,
    digits, or the underscore.
3   There may be no more than 31 characters in
    an identifier.




                                                 3
Guidelines for Identifiers

   Capitalize the first letter
   If the identifier is composed of two words
    which have been concatenated (run together)
       Capitalize the first letter of each word
       Optionally, place an underscore between the
        words
   Select identifiers that have some significance
    to the problem being solved


                                                      4
Identifiers
   Valid:
      TaxRate Last_Page Radius
   Not Valid
       Time-secs 3rdYear




                                 5
     Variables
    A variable is a memory location in the primary
    memory of a computer.

   Each variable can store a single value
   Since computers use several different internal
    representations for various types of data, a
    specific data type must be associated with
    each variable
   The value can be changed while the program
    is running, but the data type cannot be
    changed                                          6
Data Types
Fortran 90 supports five basic data types
       INTEGER
       REAL
       CHARACTER
       LOGICAL
       COMPLEX




Fortran 90 allows a programmer to define additional
data types to fit a specific application.

                                                      7
    Declarations
    Syntax

      type_name :: list of identifiers separated by commas

   A declaration reserves variables (memory
    locations) for each of the identifiers and
    associates a data type with each variable
   A declaration DOES NOT provide an initial
    value for any variable



                                                             8
     Examples of Declarations
REAL    :: A, B
INTEGER :: K
INTEGER :: N
LOGICAL :: IsThere
CHARACTER (6) :: W, T, H*17

      • W, T and H are character variables
      • W and T will hold exactly 6 characters
      • H will hold exactly 17 characters




                                                 9
    Default Types

   Fortran does not require that variables be
    declared
   If a variable is referenced without being
    declared, Fortran will give that variable a data
    type based on the first letter of its identifier
       I through N ==> INTEGER
       otherwise ==> REAL



                                                       10
The IMPLICIT Statement

   The IMPLICIT statement can be used to
    override Fortran‟s rules for assigning data
    types to undeclared variables
   Good programming style is to declare all
    variables in a program
   If the statement IMPLICIT NONE precedes
    the first declaration, the Fortran 90 compiler
    will ensure that every variable which is used
    in the program has been explicitly declared
                                                     11
Writing an INTEGER Value

   String of digits
   No commas
   Optional + or - sign
   Examples:
     21856 -89 0




                           12
Integers: Valid & Invalid
   Valid          Not Valid
       234            5-
       +236           --5
       -225           17.0
       0              14,555




                                 13
Writing a REAL Value (1)

   Fixed Point Form ( xxx.xx )
       String of digits with decimal point
       No commas
       Optional + or - sign
       Valid Real Values:
         -54.873 0.0 6.5 18.0 0.56
       NOT Valid Reals:
          12,345.67      12


                                              14
    Writing a REAL Value (2)

   Floating Point Form
       Analogous to scientific notation
       Basic form: fEn
            Fixed point real ( f ) “Mantissa”
            letter E
            integer exponent ( n )
       Interpretation f*10n
       Examples:
         6.57E-3 for 0.00657
         -45.6E4 for -456000.0
         0.7206E+3 for 720.6
                                                 15
Writing a Character Value

   Two forms
       „string‟
       “string”
   Either form can be used
   Examples
       “This is easy”
       „What is your name?‟
       “That‟s all folks”


                               16
Declaring a Constant
Syntax

    type_name, PARAMETER :: name = value


   This variant on the basic declaration is used
    to give a symbolic name to a constant
   The use of declared constants is considered
    to be a better programming practice than
    writing the value of the constant in the code
    itself unless the constant is an integral part of
    a formula and will never change value or
    precision
                                                   17
 Examples Using PARAMETER

INTEGER, PARAMETER :: NumStates = 50


REAL, PARAMETER :: PI = 3.14159


CHARACTER (*), PARAMETER :: Prompt = “next>“




                                               18
   Assignment Statement Syntax
     Syntax

       target_variable = expression




The value represented by the expression on the right
hand side of the equal sign is stored in the target
variable, replacing its previous value




                                                       19
    Assignment Statement Uses

   Store a specific value in a variable
      N = 32 ; X = -3.5 ; W = „cat‟
   Copy a value from one variable to another
      T=N
   Store a computed value in a variable
      X = 3.5 + W




                                                20
Numeric Conversions on
Assignment
INTEGER :: K, N, M
REAL    :: W, C, Y
              Integer value 6 will be stored in N
N = 6.8        (truncation rather than rounding)

X = 53        Real value 53.0 will be stored in X

K = -6        Integer value -6 will be stored in K
W=K           Real value -6.0 will be stored in W

Y = 7.8       Real value 7.8 will be stored in Y
M =N          Integer value 6 will be stored in M
                                                     21
    Character Padding and
    Truncation on Assignment
CHARACTER (5) :: A, B
CHARACTER (8) :: C
                     frogwill be stored in A
A = „frog‟            (padded out to five characters with blank at end)

                     eleph will be stored in B
B = “elephant”        (extra characters are truncated from the right end)

                                 will
                     eleph be stored in C
C=B                   (B contained eleph which must be padded to 8 characters)

             Note: The symbol represents a blank space

                                                                            22
   Numeric Expressions
A numeric expression is any mathematically valid
sequence of operators, operands, and parentheses.



An operand is a constant, variable, or value returned by a
function.




                                                             23
Arithmetic Operators


  +    add
  -    subtract
  *    multiply
  /    divide
  **   exponentiation
        A**B means AB

                        24
Result Types

   The result type is determined for each
    mathematical operation
   The type is based on the type of the
    operands
   If both operands are INTEGER, the result is
    an integer
   If at least one operand is REAL, the result is a
    real number

                                                  25
Precedence Rules

   Evaluate subexpressions in parentheses
   Determine the value returned by any function
    call
   Evaluate ** (right to left)
    2**3**5 is the same as 2**(3**5)
   Evaluate * and / from left to right
   Evaluate + and - from left to right


                                               26
Precedence Rules
     All exponentiations are performed first;
      consecutive exponentiations are performed
      from right to left
        2 ** 3 ** 2 = 2 ** 9 = 512

       All multiplications and divisions are
        performed next, in the order in which they
        appear from left to right.

         10 / 5 * 2 =   2*2= 4

                                                     27
     Precedence Rules
   The additions and subtractions are
    performed last, in the order in which they
    appear from left to right
       10 + 8 – 2 + 3 = 19
   Another example
     2 + 4 ** 2 / 2
      2 + 16 / 2
      2+8
      10
                                                 28
Characteristics of the /
Operator
   If numerator and denominator are integers,
    the quotient is truncated to an integer
    •   23/5 is 4 rather than 4.6
   If either the numerator or denominator is a
    real number, the quotient is a real number
    •   12/9.0     is    1.3333
    •   3.6/1.2    is    3.0
    •   8.6/2       is    4.3
    •   23.0/5.0   is    4.6

                                                  29
    Characteristics of the ** Operator

                    Consider A**B

   If B is a nonnegative integer, Fortran uses
    repeated multiplication to evaluate A**B
   If B is a real number, Fortran uses the
    expression eB*ln(A) to approximate A**B.
       Ex. (-4.0) ** 2.0 is undefined, because the
        logarithms of negative values are not defined.


                                                         30
     Type Conversions

   Using both integers and reals in a computation
    is a poor programming practice.
   Fortran provides some type conversion
    functions to convert a value to a different data
    type.
   Type conversions should be used to avoid
    mixed data types in an expression.
   The original value is not changed, but the
    converted value is placed in a temporary
    (unnamed) variable.

                                                       31
 Type Conversion Examples

INTEGER ==> REAL    REAL ==> INTEGER
INTEGER N           INTEGER K
REAL     X          REAL      Y
N = 15              Y = 2.8
X = 3.7 * REAL(N)   K = INT(Y) + 5
   X = 3.7 * 15.0      K=2+5
   N is unchanged      Y is unchanged


                                        32
 A Few Functions
A good programmer makes use of functions that are provided
as part of the programming language. Fortran 90 has an
extensive collection of intrinsic functions. (See Appendix D)
SQRT(X)                  Preferred to X**(0.5)
ABS(X)                   Absolute value
SIN(X), COS(X), TAN(X) Angles must be in radians
EXP(X)                   eX
LOG(X)                   ln X
LOG10(X)                 log10X
MOD(A,B)                 A mod B
                                                            33
Form of a Program
 ------------ Header portion -------------
    Initial comment block
    PROGRAM statement
--------- Specification portion ---------
    IMPLICIT NONE
    Type specification statements
 -------- Execution portion ------------
    READ, PRINT, and assignments
 -------- Ending portion ---------------
 END PROGRAM statement




                                             34
    Structure of a Line of Source Code

   Maximum of 132 characters.
   Can begin anywhere on the line.
   Two or more statements can appear on a single line if
    they are separated by semicolons.
   Blanks can be inserted to improve comprehension.
   A comment can appear at the end of the line.
   If a statement label is used, it must appear first.
    A label is an unsigned integer with at most 5 digits.
   If a statement is too long, place an ampersand, &,
    at the end and continue on the next line.
                                                            35
    Comments
      Syntax

        ! comment


   Everything from the exclamation mark (!), to
    the end of the line is a comment
   A comment can appear on a line by itself or
    at the end of some other line
   Comments are included in a program to
    provide a person with information about the
    program
   Comments are ignored by the compiler           36
The PROGRAM Statement
    Syntax

      PROGRAM program_name




   Provides a name (identifier) for the program
   Optional but strongly recommended
   Required by most programming standards
   Must be the first statement, but can be
    preceded by comments

                                                   37
The END PROGRAM Statement
    Syntax

      END PROGRAM program_name




    This is the only required statement
    Must be the last line in the source code file
    program_name must match that on the
     PROGRAM statement
    Omit the program-name if there is no
     program statement
                                                     38
    The STOP Statement
     Syntax

        STOP
     or STOP n   !n is an integer value

   Causes the program to stop its execution at
    that point
   More than one STOP statement can be
    included
   This statement is not required, but is
    recommended by some coding standards

                                                  39
     Simple Input (list-directed)
      Syntax

        READ *, input_list


   input_list is a list of variables which will
    receive the values that are read
   Each READ statement begins reading a new
    line of data
   A READ statement can read more than one
    line of data


                                                   40
    Simple Output (list-directed)
    Syntax

         PRINT *, output_list


   output_list is a list of items to be printed
         character string literals will be printed exactly
         variables will have their values printed
   Each PRINT statement starts a new line of
    output
   Fortran will use its internal rules to determine
    the location and appearance of values on
    each line
                                                              41

								
To top