CENG 303

MATLAB, MAPLE, AND FORTRAN

FOR CHEMICAL ENGINEERS

MATTEO PASQUALI
[email protected]
713-348-5830
AL B-243

FORTRAN LECTURE 1
TYPICAL COMPUTER (2001)
CENTRAL PROCESSING UNIT (CPU)

INPUT DEVICES CONTROL FLOATING POINT

UNIT & LOGIC UNITS

ULTRAFAST
FAST
CACHE
SLOW

OUTPUT DEVICES MAIN

MEMORY (RAM)

PERMANENT MEMORY
 CHOOSING YOUR WEAPONS

SPREADSHEETS Excel
SPEED & CONTROL

Maple
EASE OF USE

INTERPRETED LANGUAGES Matlab

Mathematica
Java
COMPILED LANGUAGES
C & C++
Fortran 90/95
MACHINE LANGUAGES
Assembler

WHICH WEAPON DO YOU NEED?

 OPERATING A COMPUTER (with Fortran)

UI PROGRAMMER
G
TEXT ALGORITHM
EDITOR
SOURCE CODE High-level
Language
COMPILER (Fortran) HUMAN
(TRANSLATOR) OBJECT CODE
Low-level
Language
LIBRARIES EXECUTABLE (Computer + hackers)

Process data
follow instructions
DATA CPU in executable

Understandable
RESULTS by HUMANS
PROBLEM SOLVING
BY COMPUTER-AIDED METHODS

1. FIND PROBLEM(S) (0%)

2. TRANSLATE PROBLEM
INTO ALGORITHM (10-30%)
3. TRANSLATE ALGORITHM
INTO FORTRAN (60-80%)
4. EXECUTE AND CHECK
FORTRAN PROGRAM (10%)
ALGORITHM DESIGN

ART / SCIENCE ACQUIRED WITH

TIME & PRACTICE
GUIDELINES

1. DIVIDE A BIG PROBLEM INTO

SMALLER SUBPROBLEMS
2. ISOLATE AND GENERALIZE
REPETITIVE TASKS
3. TRANSLATE EACH TASK
INTO AN ALGORITHM
4. WRITE PSEUDOCODE FOR THE ALGORITHM
ELEMENTARY TASKS OF ALGORITHMS
AND COMPUTER PROGRAMS

• INPUT (ACQUIRE DATA)

• OUTPUT (DISPLAY RESULTS)
• ASSIGNMENT OF VARIABLES
• ALGEBRA (COMPUTATIONS)
• SELECTIVE EXECUTION (MAKE CHOICES)
• REPETITIVE EXECUTION (LOOP)

How do we translate these

into Fortran commands & constructs?
FORTRAN = FORMULA TRANSLATION
BEST LANGUAGE FOR SCIENTIFIC APPLICATIONS
AND COMPUTATIONAL MATHEMATICS

STANDARD:SET OF SYNTACTIC RULES THAT

ANY COMPILER RUNNING ON
ANY COMPUTER MUST UNDERSTAND AND
TRANSLATE CORRECTLY INTO
MACHINE LANGUAGE
FORTRAN & FORTRAN-DERIVED STANDARDS ARE
PERIODICALLY UPDATED TO KEEP UP WITH
HARDWARE AND COMPILER IMPROVEMENTS
“HIGHER” LEVEL LANGUAGE
RECENT & CURRENT FORTRAN STANDARDS
•FORTRAN 77 (1978)
•Fortran 90 (1991)
•Fortran 95 (current)
•Fortran 200x (in progress)
•F (Fortran-derived language)
F95
F90
F
F77 ceng303 Newer standards:
more structured
more versatile
STRUCTURE OF A FORTRAN PROGRAM

program NAME

HEADER WITH COMMENTS, DESCRIPTION

OF PROGRAM PURPOSE, AND
PROGRAM OUTLINE

DECLARATION OF VARIABLES

BODY OF PROGRAM

end
VARIABLES
A VARIABLE IS A NAME ASSOCIATED
WITH A CERTAIN PIECE OF INFORMATION

5 TYPES OF VARIABLES, FOR REPRESENTING

DIFFERENT KINDS OF INFORMATION
•integer (3 kinds)
•real (3 kinds)
•complex (2 kinds)
•character
•logical
+ DERIVED DATA TYPES
REPRESENTATION OF VARIABLES

VARIABLES ARE REPRESENTED BY

WORDS, COMPOSED OF BYTES,
COMPOSED OF BITS

BIT = elemental circuit, ON (1) / OFF (0)

BYTE = string of 8 BITS
WORD = string of N BYTES partially
controllable
by programmer
WORD

BIT BYTE
INTEGER VARIABLES
DECLARATION
integer :: iteration
integer :: index, size, year
integer (kind = K) :: maxcount

ASSIGNMENT
USED FOR NUMBERS WITHOUT DECIMAL POINT;
NEGATIVE INTEGERS PRECEEDED BY MINUS SIGN

iteration = 0
year = 1306
index = -47
REPRESENTATION OF INTEGER VARIABLES
2-BYTE, 4-BYTE (default) OR 8-BYTE WORD
integer :: iteration 4-BYTE
integer (kind = 8 [2]) :: maxcount 8-BYTE
compiler-dependent

SELECTING APPROPRIATE KIND

integer, parameter :: two_b = selected_int_kind(4)
integer (kind = two_b) :: maxcount
compiler-independent

BYTES 2 4 8
MAX INTEGER 3.3e4 2.1e9 9.2e18
INVALID INTEGER ASSIGNMENTS

integer :: a, b, c, d
a = 3.26 not an integer, 3 will be stored

b = 12.0 confuse compiler

EXECUTION ERRORS

c = --3 only 1 algebraic sign

d = 2- sign must preceed number

COMPILATION ERRORS
REAL VARIABLES
DECLARATION
real :: time
real :: force, mass, acceleration
real (kind = K) :: gravity
ASSIGNMENT
USED FOR DECIMAL NUMBERS;
FIXED OR EXPONENTIAL NOTATION
A POINT (.) MUST ALWAYS BE PRESENT
time = 0. force = - 512.15
time = 0.0 force = - 5.1215e2
mass = 3. acceleration = 0.00406
mass = 3.0 acceleration = 4.06e-3
NEVER USE COMMAS
REMARKS
VARIABLE NAMES MUST START WITH LETTER
a3p2 bl0p 3nql

NO DIFFERENCE BETWEEN UPPERCASE

& lowercase
F77: 6 CHARACTERS
F90: 31 CHARACTERS, INCLUDE _ (underscore)

DEFAULT LIMITS ON INTEGERS & REAL

INTEGERS (4-BYTE): -231 to 231, i.e., -2e9 to 2e9
REAL (4-BYTE): smallest ~ 10-38
largest ~ 1038
PRECISION
LIMIT ON PRECISION OF REPRESENTATION
OF DECIMAL NUMBERS

DEFAULT REAL: 4-BYTE, ~ 7 Dec. DIGITS

(except on CRAY)
3.141592653... (π)
LOST
0.666666666... (2/3)
INSUFFICIENT PRECISION MAY YIELD ERRORS
1.00000004 - 1.0 0.0
POSSIBLY
LOST COMPUTER ARITHMETIC SIGNIFICANT
ERROR
CORRECT RESULT: 4e-8
HIGHER PRECISION REALS
LIMIT ON PRECISION CAN BE EXTENDED
8-BYTE REAL ~ 13-14 Dec. DIGITS
16-BYTE REAL ~ 31-32 Dec. DIGITS

VERY IMPORTANT IN SCIENTIFIC APPLICATIONS

DECLARATION
integer, parameter :: prec = selected_real_kind(13)
real (kind = prec) :: mass, force THESE VARIABLES
ASSIGNMENT HAVE AT LEAST 13
DIGITS PRECISION
force = 9.81_prec
NAMED PRECISION
mass = 3.5e-2_prec CONSTANTS
LOGICAL VARIABLES
TRUE OR FALSE ONLY
DECLARATION
logical :: proposition, condition

ASSIGNMENT
proposition = .true.
LOGICAL
condition = .false. CONSTANTS
CHARACTER VARIABLES
DECLARATION
character (len=20) :: school_name
LENGTH OF THE STRING

ASSIGNMENT
school_name = ‘Rice University’
school_name = ‘University of Minnesota’
TOO LONG: LAST 3 LETTERS
WILL BE DROPPED
SOME COMPILERS GIVE ERROR
REMARKS ON VARIABLE DECLARATIONS

AS A DEFAULT, FORTRAN ASSUMES

THAT VARIABLES STARTING WITH:

A–H REAL
I–N INTEGER
O–Z REAL

OVERRIDDEN BY EXPLICIT DECLARATIONS

integer :: step
real :: mass
logical :: proposition
IMPLICIT NONE

OVERRIDES ALL DEFAULTS

ALL VARIABLES MUST BE DECLARED

ALWAYS USE TO AVOID MISTAKES

MUST BE PLACED AT BEGINNING OF

EACH PROGRAM OR SUBROUTINE

program test
implicit none
DECLARATION OF VARIABLES
INSTRUCTIONS (PROGRAM BODY)
end program test
PARAMETER STATEMENT

ASSOCIATES PARAMETER NAME TO VALUE

VALUE CANNOT BE CHANGED IN PROGRAM

EXAMPLE

real (kind = prec), parameter :: pi = 3.1415927

...
area = pi * radius ** 2
volume = 4.0_prec / 3.0_prec * radius ** 3
...
pi = 7.12 NOT ALLOWED
ASSIGNMENT STATEMENT
SYNTAX
VARIABLE = EXPRESSION
MEANING: ASSIGN TO VARIABLE
THE VALUE EXPRESSION
EXAMPLES
a = 3.0 RIGHT HAND SIDE
x = (5.0 – 2.34) * 4.9 MUST BE
y = a + x**2 COMPLETELY DETERMINED

WRONG USE
a – 1.0 = 2.0 y - a = x**2
3.0 = a x**2 = y - a
x / 4.9 = 5.0 – 2.34
FORTRAN OPERATIONS
OPERATOR OPERATION
+ ADDITION
- SUBTRACTION
* MULTIPLICATION
/ DIVISION
** EXPONENTIATION
SIMPLE EXPRESSIONS

x + 2.0 * y
a / (m + n)
a ** 2 - 4. * (a + b) / (c – d)
3. * sqrt (a - b **2)
ORDER OF OPERATIONS

1. EXPONENTIATION; MULTIPLE
EXPONENTIATIONS ARE RIGHT TO LEFT
2. MULTIPLICATIONS AND DIVISIONS,
FROM LEFT TO RIGHT
3. ADDITIONS AND SUBTRACTIONS,
FROM LEFT TO RIGHT

EXAMPLE
b
a + b / c**d**e - 2.0 * f a+ de
−2f
c
VARIABLE TYPES IN EXPRESSIONS

ALWAYS USE HOMOGENEOUS TYPES

(ALL REALS or ALL INTEGERS) IN
EXPRESSIONS
EXAMPLES

3 / 4 0 TRUNCATION

3.0 / 4.0 0.75

EXCEPTION: EXPONENTIATION TO INTEGER POWER

1.5 ** 2 2.25 FASTER

1.5 ** 2.0 2.25 SLOWER
ASSIGNMENT OF EXPRESSIONS TO VARIABLES

real :: mass, force, acceleration

real :: mass1, mass2, lightspeed, energy

mass = 4.0
force = 8.8
acceleration = force / mass
mass1 = 1.1e-23
mass2 = 2.3e-23
lightspeed = 3.e8
energy = (mass1 + mass2) * lightspeed**2
ASSIGNMENT OF EXPRESSIONS TO VARIABLES

integer :: total, attempts, ratio

total = 15
attempts = 5
ratio = total / attempts 3

total = 18
attempts = 5
ratio = total / attempts 3
TRUNCATION
SOME INTRINSIC FUNCTIONS
FUNCTION DESCRIPTION ARG. VALUE
abs(x) ABSOLUTE VALUE INT / REAL SAME
cos(x) COSINE (RADIANS) REAL REAL
exp(x) EXPONENTIAL REAL REAL
int(x) INTEGER PART OF x REAL INT
floor(x) GREATEST INTEGER ≤ x REAL INT
fraction(x) FRACTIONAL PART OF x REAL REAL
log(x) NATURAL LOG OF x REAL REAL
max(x1,...,xN) MAXIMUM OF x1, ..., xN INT/REAL SAME
min(x1,...,xN) MINIMUM OF x1, ..., xN INT/REAL SAME
mod(x,y) x (mod y); x - int(x/y) * y INT/REAL SAME
nint(x) x ROUND TO NEAREST INT REAL INT
real(x) CONVERT x TO REAL INT REAL
sin(x) SINE (RADIANS) REAL REAL
sqrt(x) SQUARE ROOT REAL REAL
tan(x) TANGENT (RADIANS) REAL REAL
UNFORMATTED INPUT / OUTPUT

SYNTAX
read (*,*) a, b, c
READ FROM USE DEFAULT FORMAT
DEFAULT INPUT (FREE)
DEVICE (KEYBOARD)

write (*,*) e, ‘hello’, g

WRITE TO USE DEFAULT FORMAT
DEFAULT OUTPUT (DEPENDS ON
DEVICE (MONITOR) VARIABLE TYPE)
BASIC FORMATTED INPUT / OUTPUT

•DISPLAY OR STORE INFORMATION IN

ORDERED AND READABLE WAY
•RETRIEVE INFORMATION STORED IN
STRUCTURED WAY

SYNTAX
write (*, fmt=‘(STRING)’) e, ‘hello’, g
USE FORMAT SPECIFIED
BY STRING

STRING IS A SEQUENCE OF
FORMAT DESCRIPTORS
INTEGER FORMAT DESCRIPTOR

SYNTAX INTEGER

REPETITION
riw NUMBER OF DIGITS
INDICATOR TO BE PRINTED
(DEFAULT = 1) (FLUSHED RIGHT)

EXAMPLE
write (*, fmt=‘(2i6)’) index1, number1
write (*, fmt=‘(2i6)’) index2, number2

~~~~12~~~347
~~4506~–2399
BLANK SPACE MINUS SIGN
REAL (FLOATING-POINT) FORMAT DESCRIPTOR
SYNTAX DIGITS RIGHT OF
FLOATING POINT DECIMAL POINT

REPETITION
rfw.d TO BE PRINTED

INDICATOR TOTAL DIGITS

(DEFAULT = 1) TO BE PRINTED
(FLUSHED RIGHT)
EXAMPLE
write (*, fmt=‘(2f12.6)’) num1, num2
write (*, fmt=‘(2f12.6)’) num3, num4
~~~12.123456~~~–0.034700
~~450.000000~–239.930000
DECIMAL PT. MINUS SIGN
REAL (EXPONENTIAL) FORMAT DESCRIPTOR
SYNTAX DECIMAL DIGITS
EXPONENTIAL TO BE PRINTED

REPETITION
rew.d
INDICATOR TOTAL DIGITS
(DEFAULT = 1) TO BE PRINTED
(FLUSHED RIGHT)
EXAMPLE
write (*, fmt=‘(2e12.6)’) num1, num2
write (*, fmt=‘(2e12.6)’) num3, num4
INSUFFICIENT SPACING
ROUNDING
~~0.121235e2–0.347000e–1
~~0.450000e3~–0.239930e3
EXPONENT MINUS SIGN
CHARACTER FORMAT DESCRIPTOR
SYNTAX CHARACTER

REPETITION
raw
INDICATOR TOTAL CHARACTERS
(DEFAULT = 1) TO BE PRINTED
(FLUSHED LEFT)
EXAMPLE
write (*, fmt=‘(2a12)’) ‘B.S.’, ‘MIT’
write (*, fmt=‘(2e12)’) ‘Ph.D.’, ‘Rice University’
LOST
B.S.~~~~~~~~MIT~~~~~~~~~
Ph.D.~~~~~~~Rice~University
TRUNCATED
EXAMPLE OF PROGRAM INPUT / OUTPUT
program convert_temp_F_to_C
! this program converts Fahrenheit to Celsius
! and outputs results to screen
! declaration of variables
implicit none
real, parameter :: factor = 1.8 ! conversion factor F to C
real :: temp_fahr, temp_cels
! body
write (*,*) ‘Input temperature in Fahrenheit’
read (*,*) temp_fahr
temp_cels = factor * (temp_fahr – 32.0)
write (*,*) ‘The temperature is’, temp_cels, ‘degrees C’
end program convert_temp_F_to_C
BASIC DOCUMENTATION
1. PUT YOUR NAME, RICE ID#,
AND DATE AT BEGINNING OF PROGRAM
2. DECLARE AND DEFINE ALL VARIABLES
3. USE SUGGESTIVE NAMES FOR VARIABLES

GOOD BAD UGLY

force f x
acceleration a y
mass m z

4. COMMENT THE PROGRAM !!!

EXAMPLE OF PIECE OF CRAP

program crap
write (*,*) ‘temp’
read (*,*) x
y = 1.8 * (x – 32.0)
write (*,*) y
end program crap

WORKS PERFECTLY FINE,

DIFFICULT TO READ & UNDERSTAND
PROGRAM FORMAT (FREE FORM)
WRITE ANYWHERE IN FILE

COMMENTS AFTER !

energy = mass * lightspeed ** 2 ! according to Einstein

CONTINUE LINE WITH & (MAX. 132 CHAR / LINE)

write (*,*) ‘Today the outside temperature is’, temp_fahr &

‘degrees Fahrenheit’

LABELS AT BEGINNING OF LINE IF NEEDED