Introduction To Programming Using FORTRAN 95

Introduction to Programming
using
Fortran 95
Ed Jorgensen
January, 2014 Version 2.0
Cover Diagram The cover image is the plotted output from the chaos game program from chapter 11. The image was plotted with GNUplot.
Copyright Ed Jorgensen, 201 , 201!
"ou are free# to $hare % to cop&, distri'ute and transmit the wor( to )emi* % to adapt the wor( Under the following conditions# +ttri'ution. "ou must attri'ute the wor( to ,-ntroduction to .rogramming using /ortran 012 3'ut not in an& wa& that suggests that the authors endorse &ou or &our use of the wor(4. $hare +li(e. -f &ou alter, transform, or 'uild upon this wor(, &ou ma& distri'ute the resulting wor( onl& under the same, similar or a compati'le license. /or an& reuse or distri'ution, &ou must ma(e clear to others the license terms of this wor(. The 'est wa& to do this is with a lin( to http#55creativecommons.org5licenses5'&6sa5 .05 +n& of the a'ove conditions can 'e waived if &ou get permission from the cop&right holder. Nothing in this license impairs or restricts the author7s moral rights.
ii
Table of Contents
1 Introduction....................................................................................................................................... 1.1 8h& 9earn .rogramming............................................................................................................ 1.2 /ortran......................................................................................................................................... 1. :omplete /ortran 01 ;ocumentation.......................................................................................... 1.! 8hat -s + .rogram...................................................................................................................... 1.1 <perating $&stem........................................................................................................................ 2 Computer Organi ation.................................................................................................................... 2.1 +rchitecture <verview................................................................................................................ 2.2 :ompiler...................................................................................................................................... 2. -nformation )epresentation......................................................................................................... 2. .1 ;ecimal Num'ers................................................................................................................ 2. .2 =inar& Num'ers................................................................................................................... 2. . :haracter )epresentation..................................................................................................... 2.! E*ercises...................................................................................................................................... 2.!.1 >ui? >uestions..................................................................................................................... 1 1 1 1 2 2 ! ! ! ! 1 1 1 1
! "etting #tarted.................................................................................................................................. $ .1 )e@uired $(ills............................................................................................................................ A .2 .rogram /ormats......................................................................................................................... A .2.1 .rogram $tatement............................................................................................................... A .2.2 :omments............................................................................................................................ A .2. $imple <utput...................................................................................................................... B .2.! E*ample C /irst .rogram..................................................................................................... B . Te*t Editor................................................................................................................................... B .! :ompiling.................................................................................................................................... B .1 E*ecuting..................................................................................................................................... 0 .D E*ercises.................................................................................................................................... 10 .D.1 >ui? >uestions................................................................................................................... 10 .D.2 $uggested .roEects............................................................................................................. 10 4 %ortran &' ( )asic E*ements.......................................................................................................... !.1 Faria'les.................................................................................................................................... !.1.1 Faria'le Names.................................................................................................................. !.1.2 Ge&words........................................................................................................................... !.2 ;ata T&pes................................................................................................................................. !.2.1 -nteger................................................................................................................................ !.2.2 )eal.................................................................................................................................... !.2. :omple*............................................................................................................................. !.2.! :haracter............................................................................................................................ !.2.1 9ogical............................................................................................................................... !.2.D Historical ;ata T&ping....................................................................................................... iii 11 11 11 12 12 12 1 1 1 1 1
!.
;eclarations............................................................................................................................... !. .1 ;eclaring Faria'les............................................................................................................ !. .2 Faria'le )anges................................................................................................................. !. . T&pe :hec(ing................................................................................................................... !. .! -nitiali?ation....................................................................................................................... !. .1 :onstants........................................................................................................................... !.! :omments.................................................................................................................................. !.1 :ontinuation 9ines.................................................................................................................... !.1.1 E*ample............................................................................................................................. !.D ;eclarations, E*tended $i?e Faria'les...................................................................................... !.D.1 -ntegers.............................................................................................................................. !.D.2 )eal.................................................................................................................................... !.A E*ercises.................................................................................................................................... !.A.1 >ui? >uestions................................................................................................................... !.A.2 $uggested .roEects............................................................................................................. ' E+pressions...................................................................................................................................... 1.1 9iterals....................................................................................................................................... 1.1.1 -nteger 9iterals................................................................................................................... 1.1.2 )eal 9iterals....................................................................................................................... 1.1.2.1 E6Notation.................................................................................................................. 1.1. :omple* 9iterals............................................................................................................... 1.1.! :haracter 9iterals............................................................................................................... 1.1.1 9ogical :onstants.............................................................................................................. 1.2 +rithmetic <perations............................................................................................................... 1.2.1 +ssignment........................................................................................................................ 1.2.2 +ddition............................................................................................................................. 1.2. $u'traction......................................................................................................................... 1.2.! Iultiplication.................................................................................................................... 1.2.1 ;ivision............................................................................................................................. 1.2.D E*ponentiation................................................................................................................... 1. <rder of <perations................................................................................................................... 1.! -ntrinsic /unctions..................................................................................................................... 1.!.1 Iathematical -ntrinsic /unctions...................................................................................... 1.!.2 :onversion /unctions........................................................................................................ 1.!. $ummar&............................................................................................................................ 1.1 Ii*ed Iode.............................................................................................................................. 1.D E*amples................................................................................................................................... 1.A E*ercises.................................................................................................................................... 1.A.1 >ui? >uestions................................................................................................................... 1.A.2 $uggested .roEects.............................................................................................................
1! 1! 1! 1! 11 11 11 11 1D 1D 1D 1A 1A 1A 1B 1& 10 10 10 10 20 20 21 21 21 21 22 22 22 2 2 2! 2! 2! 21 21 2D 2D 2D 2A
, #imp*e Input and Output............................................................................................................... 2& D.1 <utput C 8rite........................................................................................................................... 20 D.1.1 <utput C .rint.................................................................................................................... 0 D.2 -nput C )ead.............................................................................................................................. 0 D. E*ample..................................................................................................................................... 1 iv
D.! E*ercises.................................................................................................................................... D.!.1 >ui? >uestions................................................................................................................... D.!.2 $uggested .roEects.............................................................................................................
2 2 2
$ -rogram Deve*opment.................................................................................................................... !' A.1 Understand the .ro'lem............................................................................................................ 1 A.2 :reate the +lgorithm................................................................................................................. D A. ;evelop the .rogram................................................................................................................. D A.! Test5;e'ug the .rogram............................................................................................................ A A.!.1 Error Terminolog&............................................................................................................. A A.!.1.1 :ompiler Error........................................................................................................... A A.!.1.2 )un6time Error........................................................................................................... B A.!.1. 9ogic Error................................................................................................................. 0 A.1 E*ercises.................................................................................................................................... 0 A.1.1 >ui? >uestions................................................................................................................... 0 A.1.2 $uggested .roEects............................................................................................................. !0 . #e*ection #tatements....................................................................................................................... B.1 )elational E*pressions.............................................................................................................. B.2 9ogical <perators...................................................................................................................... B. -/ $tatements............................................................................................................................. B. .1 -/ THEN $tatement........................................................................................................... B. .1.1 -/ THEN $tatement, $imple /orm............................................................................ B. .2 -/ THEN E9$E $tatement................................................................................................. B. . -/ THEN E9$E -/ $tatement............................................................................................ B.! E*ample <ne............................................................................................................................. B.!.1 Understand the .ro'lem.................................................................................................... B.!.2 :reate the +lgorithm.......................................................................................................... B.!. ;evelop the .rogram......................................................................................................... B.!.! Test5;e'ug the .rogram.................................................................................................... B.1 $E9E:T :+$E $tatement........................................................................................................ B.D E*ample Two............................................................................................................................. B.D.1 Understand the .ro'lem.................................................................................................... B.D.2 :reate the +lgorithm.......................................................................................................... B.D. ;evelop the .rogram......................................................................................................... B.D.! Test5;e'ug the .rogram.................................................................................................... B.A E*ercises.................................................................................................................................... B.A.1 >ui? >uestions................................................................................................................... B.A.2 $uggested .roEects............................................................................................................. & /ooping............................................................................................................................................ 0.1 :ounter :ontrolled 9ooping..................................................................................................... 0.2 EJ-T and :":9E $tatements................................................................................................... 0. :ounter :ontrolled E*ample..................................................................................................... 0. .1 Understand the .ro'lem.................................................................................................... 0. .2 :reate the +lgorithm.......................................................................................................... 0. . ;evelop the .rogram......................................................................................................... v 41 !1 !2 !2 ! ! ! !! !1 !1 !D !A !B !0 11 11 11 12 12 1 1 1! '$ 1A 10 10 D0 D0 D0
0. .! Test5;e'ug the .rogram.................................................................................................... 0.! :onditional :ontrolled 9ooping............................................................................................... 0.1 :onditionall& :ontrolled 9oop E*ample.................................................................................. 0.1.1 Understand the .ro'lem.................................................................................................... 0.1.2 :reate the +lgorithm.......................................................................................................... 0.1. ;evelop the .rogram......................................................................................................... 0.1.! Test5;e'ug the .rogram.................................................................................................... 0.D E*ercises.................................................................................................................................... 0.D.1 >ui? >uestions................................................................................................................... 0.D.2 $uggested .roEects............................................................................................................. 10 %ormatted Input0Output.............................................................................................................. 10.1 /ormat..................................................................................................................................... 10.2 /ormat $pecifiers.................................................................................................................... 10. -nteger /ormat $pecifier.......................................................................................................... 10.! )eal /ormat $pecifier.............................................................................................................. 10.1 9ogical /ormat $pecifier......................................................................................................... 10.D :haracter /ormat $pecifier..................................................................................................... 10.A +dvance :lause....................................................................................................................... 10.B E*ample................................................................................................................................... 10.B.1 Understand the .ro'lem.................................................................................................. 10.B.2 :reate the +lgorithm........................................................................................................ 10.B. ;evelop the .rogram....................................................................................................... 10.B.! Test5;e'ug the .rogram.................................................................................................. 10.0 E*ercises.................................................................................................................................. 10.0.1 >ui? >uestions................................................................................................................. 10.0.2 $uggested .roEects........................................................................................................... 11 Characters and #trings................................................................................................................. 11.1 :haracter and $tring :onstants............................................................................................... 11.2 :haracter Faria'le ;eclaration................................................................................................ 11. :haracter Faria'le -nitiali?ation.............................................................................................. 11.! :haracter :onstants................................................................................................................. 11.1 :haracter +ssignment.............................................................................................................. 11.D :haracter <perators................................................................................................................. 11.A :haracter $u'strings................................................................................................................ 11.B :haracter :omparisons........................................................................................................... 11.0 -ntrinsic :haracter <perations................................................................................................. 11.10 E*ample................................................................................................................................. 11.10.1 Understand the .ro'lem................................................................................................. 11.10.2 :reate the +lgorithm...................................................................................................... 11.10. ;evelop the .rogram..................................................................................................... 11.10.! Test5;e'ug the .rogram................................................................................................ 11.11 E*ercises................................................................................................................................ 11.11.1 >ui? >uestions............................................................................................................... 11.11.2 $uggested .roEects.........................................................................................................
D1 D1 D D D D! D1 D1 D1 DD ,& D0 D0 A0 A1 A1 A2 A A A! A! A! AD AA AA AA $& A0 B0 B0 B0 B1 B1 B1 B2 B2 B B B B! B1 B1 B1 BD
vi
12 %i*e Operations.............................................................................................................................. 12.1 /ile <pen................................................................................................................................. 12.2 /ile 8rite................................................................................................................................. 12. /ile )ead.................................................................................................................................. 12.! )ewind..................................................................................................................................... 12.1 =ac(space................................................................................................................................ 12.D :lose /ile................................................................................................................................. 12.A E*ample................................................................................................................................... 12.A.1 Understand the .ro'lem.................................................................................................. 12.A.2 :reate the +lgorithm........................................................................................................ 12.A. ;evelop the .rogram....................................................................................................... 12.A.! Test5;e'ug the .rogram.................................................................................................. 12.B E*ercises.................................................................................................................................. 12.B.1 >ui? >uestions................................................................................................................. 12.B.2 $uggested .roEects...........................................................................................................
.$ BA BB BB B0 B0 00 00 00 00 01 02 02 0 0
1! #ing*e Dimension 1rrays.............................................................................................................. &' 1 .1 +rra& ;eclaration.................................................................................................................... 01 1 .1.1 $tatic ;eclaration............................................................................................................. 01 1 .1.2 $tatic +rra& ;eclaration.................................................................................................. 0D 1 .1. ;&namic +rra& ;eclaration............................................................................................. 0D 1 .1. .1 ;&namic +rra& +llocation....................................................................................... 0A 1 .2 +ccessing +rra& Elements....................................................................................................... 0A 1 . -mplied ;o69oop..................................................................................................................... 0B 1 .! -nitiali?ing +rra&s.................................................................................................................... 0B 1 .1 E*ample................................................................................................................................... 00 1 .1.1 Understand the .ro'lem.................................................................................................. 00 1 .1.2 :reate the +lgorithm........................................................................................................ 00 1 .1. ;evelop the .rogram..................................................................................................... 101 1 .1.! Test5;e'ug the .rogram................................................................................................ 10 1 .D +rra&s of $trings.................................................................................................................... 10 1 .A E*ercises................................................................................................................................ 10! 1 .A.1 >ui? >uestions............................................................................................................... 10! 1 .A.2 $uggested .roEects......................................................................................................... 101 14 2u*tidimensiona* 1rrays............................................................................................................ 1!.1 +rra& ;eclaration.................................................................................................................. 1!.1.1 $tatic ;eclaration........................................................................................................... 1!.1.2 ;&namic ;eclaration..................................................................................................... 1!.1. ;&namic +rra& +llocation............................................................................................. 1!.2 +ccessing +rra& Elements..................................................................................................... 1!. E*ample................................................................................................................................. 1!. .1 Understand the .ro'lem................................................................................................. 1!. .2 :reate the +lgorithm...................................................................................................... 1!. . ;evelop the .rogram..................................................................................................... 1!. .! Test5;e'ug the .rogram................................................................................................ 1!.! E*ercises................................................................................................................................ vii 10$ 10A 10B 10B 10B 100 110 110 111 112 11 11!
1!.!.1 >ui? >uestions............................................................................................................... 11! 1!.!.2 $uggested .roEects......................................................................................................... 11! 1' #u3programs................................................................................................................................ 11.1 $u'program T&pes................................................................................................................. 11.2 .rogram 9a&out..................................................................................................................... 11.2.1 -nternal )outines............................................................................................................ 11.2.2 E*ternal )outines........................................................................................................... 11. +rguments.............................................................................................................................. 11. .1 +rgument -ntent............................................................................................................. 11.! Faria'le $cope....................................................................................................................... 11.1 Using /unctions and $u'routines.......................................................................................... 11.1.1 +rgument .assing.......................................................................................................... 11.D /unctions............................................................................................................................... 11.D.1 -ntrinsic /unctions......................................................................................................... 11.D.2 User6;efined /unctions................................................................................................. 11.D.2.1 $ide Effects............................................................................................................ 11.A $u'routines............................................................................................................................ 11.B E*ample................................................................................................................................. 11.B.1 Understand the .ro'lem................................................................................................ 11.B.2 :reate the +lgorithm...................................................................................................... 11.B. ;evelop the .rogram..................................................................................................... 11.B.! Test5;e'ug the .rogram................................................................................................ 11.0 E*ercises................................................................................................................................ 11.0.1 >ui? >uestions............................................................................................................... 11.0.2 $uggested .roEects......................................................................................................... 1, Derived Data 4ypes..................................................................................................................... 1D.1 ;efinition............................................................................................................................... 1D.2 ;eclaration............................................................................................................................ 1D. +ccessing :omponents.......................................................................................................... 1D.! E*ample <ne......................................................................................................................... 1D.!.1 Understand the .ro'lem................................................................................................ 1D.!.2 :reate the +lgorithm...................................................................................................... 1D.!. ;evelop the .rogram..................................................................................................... 1D.!.! Test5;e'ug the .rogram................................................................................................ 1D.1 +rra&s of ;erived ;ata.......................................................................................................... 1D.D E*ample Two......................................................................................................................... 1D.D.1 Understand the .ro'lem................................................................................................ 1D.D.2 :reate the +lgorithm...................................................................................................... 1D.D. ;evelop the .rogram..................................................................................................... 1D.D.! Test5;e'ug the .rogram................................................................................................ 1D.A E*ercises................................................................................................................................ 1D.A.1 >ui? >uestions............................................................................................................... 1D.A.2 $uggested .roEects......................................................................................................... 11$ 11A 11A 11B 11B 11B 11B 11B 11B 110 110 110 120 120 120 122 12 12! 121 12D 12D 12D 12B 1!1 1 1 1 2 1 2 1 1 1 ! 1 ! 1 A 1 A 1 B 1 B 1 0 1!0 1!2 1! 1! 1!
1$ 2odu*es........................................................................................................................................ 14' viii
1A.1 Iodule ;eclaration............................................................................................................... 1A.2 Use $tatement........................................................................................................................ 1A. Updated :ompilation :ommands......................................................................................... 1A.! Iodule E*ample .rogram..................................................................................................... 1A.!.1 Understand the .ro'lem................................................................................................ 1A.!.2 :reate the +lgorithm...................................................................................................... 1A.!. ;evelop the .rogram..................................................................................................... 1A.!. .1 Iain .rogram........................................................................................................ 1A.!. .2 Iodule )outines.................................................................................................... 1A.!.! :ompile the .rogram..................................................................................................... 1A.!.1 Test5;e'ug the .rogram................................................................................................ 1A.1 E*ercises................................................................................................................................ 1A.1.1 >ui? >uestions............................................................................................................... 1A.1.2 $uggested .roEects......................................................................................................... 1. 5ecursion..................................................................................................................................... 1B.1 )ecursive $u'routines........................................................................................................... 1B.2 )ecursive .rint =inar& E*ample........................................................................................... 1B.2.1 Understand the .ro'lem................................................................................................ 1B.2.2 :reate the +lgorithm...................................................................................................... 1B.2. ;evelop the .rogram..................................................................................................... 1B.2.! Test5;e'ug the .rogram................................................................................................ 1B. )ecursive /unctions.............................................................................................................. 1B.! )ecursive /actorial E*ample................................................................................................. 1B.!.1 Understand the .ro'lem................................................................................................ 1B.!.2 :reate the +lgorithm...................................................................................................... 1B.!. ;evelop the .rogram..................................................................................................... 1B.!.! Test5;e'ug the .rogram................................................................................................ 1B.1 )ecursive /actorial /unction :all Tree................................................................................. 1B.D E*ercises................................................................................................................................ 1B.D.1 >ui? >uestions............................................................................................................... 1B.D.2 $uggested .roEects......................................................................................................... 1& Character #tring 0 6umeric Conversions................................................................................. 10.1 :haracter $tring to Numeric :onversion.............................................................................. 10.2 Numeric to :haracter $tring :onversion.............................................................................. 10. E*ercises................................................................................................................................ 10. .1 >ui? >uestions............................................................................................................... 10. .2 $uggested .roEects......................................................................................................... 20 #ystem #ervices........................................................................................................................... 20.1 ;ate and Time....................................................................................................................... 20.1.1 ;ate and Time <ptions.................................................................................................. 20.1.2 ;ate and Time E*ample .rogram.................................................................................. 20.2 :ommand 9ine +rguments.................................................................................................... 20.2.1 +rgument :ount............................................................................................................. 20.2.2 Get +rguments............................................................................................................... i*
1!1 1!D 1!D 1!A 1!A 1!B 1!B 1!B 1!0 110 110 111 111 111 1'! 11 11! 11! 11! 111 11D 11D 11D 11A 11A 11A 11B 110 1D0 1D0 1D0 1,! 1D 1D1 1DD 1DD 1DA 1,& 1D0 1D0 1A0 1A2 1A 1A
20.2. :ommand 9ine +rguments, E*ample .rogram............................................................. 20. E*ercises................................................................................................................................ 20. .1 >ui? >uestions............................................................................................................... 20. .2 $uggested .roEects.........................................................................................................
1A! 1AA 1AA 1AA
21 1ppendi+ 1 ( 1#CII 4a3*e.......................................................................................................... 1$& 22 1ppendi+ ) ( 7indo8s #tart9:p Instructions......................................................................... 22.1 8or(ing /iles........................................................................................................................ 22.2 <'taining The :ompiler........................................................................................................ 22. :ommand .rompt.................................................................................................................. 22. .1 8indows J.5Fista5A...................................................................................................... 22. .2 8indows B..................................................................................................................... 22. . :ommand .rompt 8indow........................................................................................... 22. .! ;evice and ;irector&..................................................................................................... 22.! :ompiler -nstallation Ferification......................................................................................... 22.1 :ompilation........................................................................................................................... 22.D E*ecuting............................................................................................................................... 22.A E*ample................................................................................................................................. 2! 1ppendi+ C ( 5andom 6um3er "eneration............................................................................ 2 .1 -nitiali?ation........................................................................................................................... 2 .2 Generating )andom Num'er................................................................................................. 2 . E*ample................................................................................................................................. 2 .! E*ample................................................................................................................................. 24 1ppendi+ D ( Intrinsic %unctions.............................................................................................. 2!.1 :onversion /unctions............................................................................................................ 2!.2 -nteger /unctions................................................................................................................... 2!. )eal /unctions....................................................................................................................... 2!.! :haracter /unctions............................................................................................................... 2!.1 :omple* /unctions................................................................................................................ 2!.D +rra& /unctions..................................................................................................................... 2!.A $&stem -nformation /unctions.............................................................................................. 2' 1ppendi+ E ( Visua*i ation 8ith "6:p*ot............................................................................... 21.1 <'taining GNUplot............................................................................................................... 21.2 /ormatting .lot /iles............................................................................................................. 21.2.1 Header............................................................................................................................ 21.2.2 /ooter............................................................................................................................. 21. .lotting /iles.......................................................................................................................... 21.! E*ample................................................................................................................................. 21.!.1 .lot .rogram.................................................................................................................. 21.!.2 .lot /ile.......................................................................................................................... 21.!. .lot <utput..................................................................................................................... 1.1 1B1 1B1 1B2 1B2 1B2 1B2 1B2 1B 1B 1B 1B! 1.' 1B1 1B1 1BD 1BA 1.& 1B0 1B0 100 100 101 101 102 1&! 10 10 10! 10! 10! 10! 101 10D 10D
2, 1ppendi+ % ( ;ui ;uestion 1ns8ers....................................................................................... 1&$ 2D.1 >ui? >uestion +nswers, :hapter 1....................................................................................... 10A *
2D.2 >ui? >uestion +nswers, :hapter 2....................................................................................... 2D. >ui? >uestion +nswers, :hapter ....................................................................................... 2D.! >ui? >uestion +nswers, :hapter !....................................................................................... 2D.1 >ui? >uestion +nswers, :hapter 1....................................................................................... 2D.D >ui? >uestion +nswers, :hapter D....................................................................................... 2D.A >ui? >uestion +nswers, :hapter A....................................................................................... 2D.B >ui? >uestion +nswers, :hapter B....................................................................................... 2D.0 >ui? >uestion +nswers, :hapter 0....................................................................................... 2D.10 >ui? >uestion +nswers, :hapter 10................................................................................... 2D.11 >ui? >uestion +nswers, :hapter 11.................................................................................... 2D.12 >ui? >uestion +nswers, :hapter 12................................................................................... 2D.1 >ui? >uestion +nswers, :hapter 1 ................................................................................... 2D.1! >ui? >uestion +nswers, :hapter 1!................................................................................... 2D.11 >ui? >uestion +nswers, :hapter 11................................................................................... 2D.1D >ui? >uestion +nswers, :hapter 1D................................................................................... 2D.1A >ui? >uestion +nswers, :hapter 1A................................................................................... 2D.1B >ui? >uestion +nswers, :hapter 1B................................................................................... 2D.10 >ui? >uestion +nswers, :hapter 10................................................................................... 2D.20 >ui? >uestion +nswers, :hapter 20...................................................................................
10A 10A 10B 10B 100 100 100 200 201 202 202 20 20! 20! 201 20D 20D 20B 20B
2$ 1ppendi+ " ( %ortran &' <ey8ords......................................................................................... 20& Inde+................................................................................................................................................... 21!
Illustration Index
-llustration 1# :omputer +rchitecture........................................................................................................ -llustration 2# /ortran 01 :ompile .rocess................................................................................................! -llustration # /actorial )ecursion Tree.................................................................................................110
*i
*ii
Introduction
:omputers are ever&where in our dail& lives. =etween the des(top, laptop, phone, 'an(, and vehicle, it is difficult to completel& get awa& from computers. -t onl& ma(es sense to learn a little a'out how a computer reall& wor(s. This te*t provides an introduction to programming and pro'lem solving using the /ortran 01 programming language. This introduction is geared for non6computer science maEors. +s such, this te*t is not a complete, comprehensive guide to the /ortran 01 programming language. The primar& focus is on an introduction to pro'lem solving and algorithm development. +s such, man& details of the /ortran 01 language are omitted.
1.1 Why Learn Programming

/or science and technical maEors, computers are used e*tensivel& in all aspects of ever& discipline. 9earning the 'asics of how computers wor( and how programs are created is useful and directl& applica'le. .rogramming a computer is 'asicall& applied pro'lem solving. "ou are given a pro'lem, the pro'lem is anal&?ed, a solution is developed, and then that solution is implemented and tested. Enhanced pro'lem solving s(ills can 'e applied to an& endeavor. These 'asic s(ills, once developed, can 'e applied to other programming languages, I+T9+=, or even spreadsheet macro7s. Unfortunatel&, learning programing and how a computer reall& wor(s ma& ruin some = movies.
1. Fortran
/ortran is a programming language often used '& the scientific communit&. -ts name is a contraction of /<)mula T)+Nslation. /<)T)+N is one of the earliest programming languages. This te*t utili?es the /ortran 00501 standard. <lder versions of /ortran, li(e /ortran AA, are not referenced. The older /ortran versions have less features and re@uire additional, often 'urdensome, formatting re@uirements.
1.! Com"lete Fortran 95 #ocumentation

This te*t it is not a comprehensive or complete reference to the /ortran 01 language. The entire GNU /ortran compiler documentation is availa'le on6line at the following location#
http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gfortran/
-f this location changes, a we' search will 'e a'le to find the new location.
:hapter 1 K -ntroduction
1.$ What Is % Program

+ computer program is a series of instructions which ena'les the computer to perform a designated tas(. +s this te*t will demonstrate, a computer must 'e told what to do in precise, step6'&6step detail. These steps might include o'taining data, arithmetic operations 3additional, su'traction, multiplication, division, etc.4, data storage, and information output. The computer will perform these tas(s as instructed, even if the& don7t alwa&s ma(e sense. :onse@uentl&, it is the programmer who must develop a solution to the pro'lem.
1.5 &"erating 'ystem

The <perating $&stem, or <$, is an interface 'etween the user and the hardware 3:.U, memor&, screen, dis( drive, etc.4. The <$ is responsi'le for the management of the hardware, coordination of activities, and the sharing of the resources of the computer that acts as a host for computing applications run on the machine. The common operating s&stems include various versions of 8indows. I+: <$ J, and UN-J59inu*. .rograms written in /ortran will wor( on these operating s&stems.
Com"uter &rgani(ation
=efore writing programs, it is useful to understand some 'asics a'out how a computer is organi?ed. This section provides a 'rief, high6level overview of the 'asic components of a computer and how it is organi?ed.
.1 %rchitecture &)er)ie*
The 'asic components of a computer include a :entral .rocessing Unit 3:.U4, )andom +ccess Iemor& 3)+I4, .rimar& $torage, and -nput5<utput devices 3i.e., screen, (e&'oard, and mouse4, and an interconnection referred to as =U$. The primar& storage ma& 'e a $olid $tate ;rive 3$$;4, dis( drive, or other t&pe of primar& storage media. + ver& 'asic diagram of a computer architecture is as follows# Random ccess Memory (R M) #"S ($nterconnection)
!P"
Screen / Keyboard / Mouse
Primary Storage (i.e., SSD, Disk Drive or Other Storage Media)
Illustration 1: Computer Architecture .rograms and data are t&picall& stored on the dis( drive. 8hen a program is e*ecuted, it must 'e copied from the dis( drive into the )+I memor&. The :.U e*ecutes the program from )+I. This is similar to storing a term paper on the dis( drive, and when writing5editing the term paper, it is copied from the dis( drive into memor&. 8hen done, the updated version is stored 'ac( to the dis( drive.
:hapter 2 K :omputer <rgani?ation
. Com"iler
.rograms can 'e written in the /ortran programming language. However, the :.U does not read /ortran directl&. -nstead, the /ortran program that we create will 'e converted into 'inar& 317s and 07s4 '& the compiler. These 17s and 07s are t&picall& referred to as machine language. The :.U will read the instructions and information, represented in 'inar& as machine language, and perform the commands from the program.
%ortran &' Program
!om(i)er
*+ecutab)e %i)e
Illustration 2: Fortran 95 Compile Process The compiler is a program itself and is re@uired in order to create the files needed to e*ecute programs written in /ortran 01.
.! Information +e"resentation
+ll information, including num'ers, characters, and instructions are represented in the computer in 'inar& 317s and 07s4. The information, num'ers in this e*ample, is converted into 'inar& representation 317s and 07s4 for storage in the computer. /ortunatel&, this is generall& done transparentl&.
2.3.1
Decimal Numbers
=efore discussing 'inar& num'ers, a 'rief review of the decimal s&stem is presented. The num'er L12 !L as, Thousands 10 1000 1 8hich means, Hundreds 102 100 2 Tens 101 10 <nes 100 1 !
12 ! = 1 1000 2100 10 ! 1 12 ! = 1 10 2 102 101 ! 100
The decimal s&stem is base 10 using the digits 0 through 0. !
:hapter 2 M :omputer <rgani?ation
2.3.2
Binary Numbers
+ 'it is the 'asic unit of information in computing and digital communications. + 'it can have onl& one of two values, 0 or 1. The term 'it is a contraction of 'inar& digit. The 'inar& s&stem, as well as its math, operates in base 2, using two s&m'ols, 0 and 1. 2A 12B 0 2D D! 0 21 2 0 2! 1D 0 2 B 1 22 ! 1 21 2 0 20 1 1
-n 'ase 2, we put the digits 0 or 1 in columns 20, 21, 2 , and so on. /or e*ample, 11012 = 1 2 1 2 0 2 1 2 = B ! 1 8hich is decimal is 1
10
+ set of B 'its is a referred to as a '&te. :omputer data is t&picall& allocated in '&tes or sets of '&tes.
2.3.3
Character Representation
:haracters are represented using the +merican $tandard :ode for -nformation -nterchange 3+$:--4. )efer to +ppendi* +.
.$ ,xercises
=elow are some @ui? @uestions 'ased on this chapter.
2.4.1
Quiz Questions
=elow are some @ui? @uestions. 14 How is information represented in the computerN 24 8hat does the /ortran compiler doN 4 8hat architecture component connects the memor& to the :.UN !4 8hat are the following 'inar& values in decimalN a4 00001012 '4 00010012 c4 00011012 d4 00101012 14 How are characters represented in the computerN
:hapter 2 K :omputer <rgani?ation
D4 8here are programs stored when the computer is turned offN A4 8here must programs 'e located when the& are e*ecutingN
-etting 'tarted
This section provides a 'rief overview of how to get started. This includes the general process for creating a ver& simple program, compiling, and e*ecuting the program. $ome detailed steps regarding wor(ing with files, o'taining the compiler, and compiling a program are included in Appendix B !indo"s #tart$up Instructions.
!.1 +e.uired '/ills

=efore starting, &ou should have some 'asic computer s(ills, including the following#

+'ilit& to use a we' 'rowser =asic understanding of hierarchical computer director& structure /ile manipulation 3create, delete, rename, move, etc.4 Usage of the command prompt 38indows4 or terminal interface 3Uni*, I+:4 +'ilit& to edit a te*t file -ncludes selecting and learning a te*t editor 3i.e., Notepad, NotepadOO, emacs, etc.4
-f &ou are unsure a'out an& of these re@uirements &ou will need to learn them 'efore continuing. /ortunatel&, the& are not difficult. +dditionall&, there are numerous tutorials availa'le on the 8e'. The following sections assume that the /ortran 01 compiler is installed and availa'le. /or additional information regarding o'taining and installing the compiler, refer to +ppendi* =. The /ortran 01 compiler is availa'le for download at no cost.
!. Program Formats
/ortran 01 programs must 'e written and formatted in a specific manner. The following sections summari?e the 'asic program elements followed '& a simple e*ample.
3.2.1
Program tatement
+ /ortran 01 program is started with a program statement, 7program <name>7, and ended with an end program statement, 7end program <name>7. )efer to the e*ample first program to see an e*ample of these statements.
3.2.2
Comments
:omments are information for the programmer and are not read '& the computer. /or e*ample, comments t&picall& include information a'out the program. /or programming assignments, the comments should include the programmer name, assignment num'er, and a 'rief description of the program.
:hapter
K Getting $tarted
3.2.3
imple !utput
write(*,*) "Hello World"
+ program can displa& a simple message to the screen '& using the "rite statement. /or e*ample#
8ill displa& the message Hello World to the screen. +dditional information regarding the write statement and outputting information is provided in later chapters.
3.2.4
"#ample $ %irst Program
The following trivial program illustrates the initial formatting re@uirements.

! Simple Example Program program first write (*,*) "Hello World" end program first
-n this e*ample, the program is named 7first7. This file is t&picall& referred to as the source file.
!.! Text ,ditor

The first step is to create a te*t file named hw.f95 using a te*t editor. -t is useful to place programs and various files into a wor(ing director&. This wa& the files can 'e easil& found and not confused with other, unrelated files and data. The hw.f95 file should 'e created and placed in a user created wor(ing director&. /or this e*ample, a wor(ing director& named 7fortran7 was created and the file created and edited in that location. + file name is t&picall& comprised of two partsP a name and an e*tension. -n this e*ample, the file name is hw and the e*tension is .f95. The usual e*tension for this and future programs will 'e .f95 which indicates that the file is a /ortran 01 source file. The following e*amples will use the hw.f95 file name. -f desired, a different file name ma& 'e used. However, the name will need to 'e adEusted for the compiler and e*ecute steps in the following sections.
!.$ Com"iling
<nce the program is t&ped into a file, the file must 'e compiled. :ompiling will convert the human reada'le /ortran program, or source file, into a computer reada'le version 3in 'inar&4. -n order to compile, the command prompt 38indows4 or terminal interface 3Uni*, I+:4 is re@uired. This interface will allow commands to 'e t&ped directl& into the computer 3instead of using a mouse4. <nce started, it is t&picall& necessar& to change directories 3from the default location4 to the location of where the hw.f95 source file was located 3form the previous steps4. :hanging directories is t&picall& done with a cd <directoryName> command. /or e*ample, cd fortran 3which is the name of the director& used in this e*ample4. The prompt t&picall& changes to include the current director& location.
:hapter
M Getting $tarted
-n the e*ample 'elow, the commands t&ped '& the user are displa&ed in 'old. The regular 3non6'olded4 te*t refers to prompts or other information displa&ed '& the computer 3which will not need to 'e t&ped4. To compile the e*ample program, the following command would 'e entered#
C:\fortran> gfortran -o hw hw.f95
This command will tell the 7g=ortran7 compiler to read the file hw.f95 and, if there are no errors, create an e*ecuta'le file. <n 8indows 'ased machines the e*ecuta'le file is named hw.exe. +nd on Uni* or Iac 'ased machines, the e*ecuta'le is named hw 3no e*tension4. -f there is an error, the compiler will generate an error message, sometimes cr&ptic, and provide a line num'er. $uch errors are usuall& the result of mist&ping one of the instructions. +n& errors must 'e resolve 'efore continuing.
!.5 ,xecuting
To e*ecute or run a program on a 8indows 'ased machine, t&pe the name of the e*ecuta'le file. /or e*ample, to e*ecute or run the hw.exe program#
C:\fortran> hw Hello World C:\fortran>
8hich will e*ecute the e*ample program and displa& the ,Hello 8orld2 message to the screen. + more complete e*ample is as follows#
-t is not necessar& to t&pe the e*tension 3i.e., ,.e*e24 portion of the file name.
:hapter
K Getting $tarted
To e*ecute or run a program on a Uni* or I+: 'ased machine, t&pe ,.52 and the name of the e*ecuta'le file. /or e*ample, to e*ecute or run the hw program#
c:\fortran> ./hw Hello World c:\fortran>
The output 37Hello 8orld7 as displa&ed on the screen4 will 'e the same for 8indows, Uni*, or I+: 'ased machines.
!.0 ,xercises
=elow are some @ui? @uestions and proEect suggestions 'ased on this chapter.
3.&.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat the the input file for the compilerN 24 8hat is the output file from the compilerN 4 /ortran program must start with and end with what statementN !4 How are /ortran 01 comments mar(edN 14 8hat is the t&pical /ortran 01 source file e*tensionN D4 8hat is the t&pical /ortran 01 compiler output file e*tension 3after the program is compiled4N
3.&.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 :reate a wor(ing director& for the storage of program files 3on the computer 'eing used4. 24 <'tain and install the GNU /ortran 01 compiler on a suita'le computer. )efer to +ppendi* = as needed. 4 T&pe in the hello world program, compile, and e*ecute the program. !4 Update the e*ample program to displa& &our name in addition to the Hello 8orld message.
10
Fortran 95 1 2asic ,lements
=efore 'eginning to writing programs, it is necessar& to (now some of the 'asic elements of the /ortran language. This section descri'es some of the 'asic elements of /ortran. +dditional information will 'e added in later sections.
$.1 3ariables
The 'asic concept in a program is the concept of a varia'le. Faria'les in a program are li(e varia'les in an alge'raic e*pression. The& are used to hold values and then write mathematical e*pressions using them. /ortran allows us to have varia'les of different t&pes. + varia'le can hold one value at a time. -f another value is placed in the varia'le, the previous value is over6written and lost. Faria'le Name Q !2
Faria'les must 'e declared at the start of the program 'efore the& are used.
4.1.1
)ariable Names
Each varia'le must 'e named. The varia'le name is how varia'les, which are memor& locations, are referred to '& the program. + varia'le name must start with a letter, followed '& letters, num'ers, or an underscore 3,R24 and ma& not 'e longer than 2 characters. :apital letters are treated the same wa& as lower6case letters, 3i.e., ,+++2 is the same varia'le as ,aaa24.
/or e*ample, some valid varia'le names are as follows#

x today next_month summation1
$ome invalid e*amples include#

1today this_is_a_variable_name_with_way_way_to_many_characters_in_it next@month next month today!
Note that the space 3'etween ne*t and month4 or the special character, S, is not allowed. +dditionall&, each varia'le must have a t&pe associated as e*plained in the following sections.
11
:hapter ! K /ortran 01 C =asic Elements
4.1.2
*ey+or's
-n programming, a (e&word is a word or identifier that has a special /ortran meaning. /or e*ample, in the ,hello world2 program from the previous chapter, the word program had a special meaning in that it used to note the start or 'eginning of a program. +dditionall&, the word "rite has a special meaning to note an output action 3e.g., writing some information to an output device, li(e the screen4.
$uch (e&words are reserved in that the& can not 'e used for an&thing else such as varia'le names. That is, a varia'le name of program or write is not allowed. +s additional /ortran 01 statements and language constructs are e*plained, more (e&words will 'e identified. -n general, words used for /ortran language statements, attri'utes, and constructs will li(el& 'e (e&words. + complete list of (e&words or reserved words is located in +ppendi* /.
$. #ata Ty"es
/ortran, li(e man& other high level programming languages, supports several different data t%pes to ma(e data manipulation easier. The most fre@uentl& used data t&pes are integer and floating point. <ther data t&pes are comple* num'ers, characters and logical data. -n a /ortran statement, data can appear either as a literal 3e.g., an actual value such as .1!110, 1D, 61.!e6!4 or as a varia'le name which identifies a location in memor& to store the data. The five 'asic /ortran 01 data t&pes are as follows# 4ype integer rea* comp*e+ character *ogica* Description Faria'le that is an integer or whole num'er 3not a fraction4 that can 'e positive, negative, or ?ero. Faria'le that can set set to a real num'er. Faria'le that can 'e set to a comple* num'er. Faria'le that is a character or se@uence of characters. Faria'le that can onl& 'e set to .true. or .false.
-t is also possi'le to have derived t&pes and pointers. =oth of these can 'e useful for more advanced programs and are descri'ed in later chapters.
4.2.1
,nteger
+n integer1 is a whole num'er 3not a fraction4 that can 'e positive, negative, or ?ero. E*amples include the num'ers 10, 0, 621, and 1,1!B. -ntegers are the num'ers people are most familiar with, and the& serve a crucial role in mathematics and computers. +ll integers are whole num'ers, so operations li(e one divided '& two 31524 is 0 since the result must 'e a whole num'er. /or integer division, no rounding will occur as the fractional part is truncated.
1 /or more information regarding integers, refer to# http#55en.wi(ipedia.org5wi(i5-nteger
12
:hapter ! M /ortran 01 C =asic Elements
4.2.2
Real
+ real num'er2 includes the fractional part, even if the fractional part is 0. )eal num'ers, also referred to as floating point num'ers, include 'oth rational num'ers and irrational num'ers. E*amples of irrational num'ers or num'ers with repeating decimals include T, 2 and e. +dditional e*amples include 1.1, 1.0, and .1!110. /ortran 01 will accept 1. as 1.0. +ll e*amples in this te*t will include the ,.02 to ensure clarit&.
4.2.3
Comple#
+ comple* num'er , in mathematics, is a num'er comprising a real num'er and an imaginar& num'er. -t can 'e written in the form of a O bi, where a and b are real num'ers, and the i is the standard imaginar& unit with the propert& that i2 U V1.0. The comple* num'ers contain the ordinar& real num'ers, 'ut e*tend them '& adding in e*tra num'ers li(e an e*tra dimension. This data t&pe is not used e*tensivel&, 'ut can 'e useful when needed.
4.2.4
Character
+ character! is a s&m'ol li(e a letter, numerical digit, or punctuation. + string1 is a se@uence or set of characters. :haracters and strings are t&picall& enclosed in @uotes. /or e*ample, the upper case letter ,W2 is a character and ,Hello 8orld2 is a string. The characters are represented in a standardi?ed format referred to as +$:--.
4.2.-
.ogical
+ logicalD is onl& allowed to have two values, true or &alse. + logical can also 'e referred to as a 'oolean. -n /ortran, the true and false values are formall& e*pressed as .true. or .=a*se. which are also called logical constants. The leading and trailing . 3period4 are re@uired for the true and false constants.
4.2.&
/istorical Data 0yping
Unless a varia'le was e*plicitl& t&ped, older versions of /ortran implicitl& assumed a t&pe for a varia'le depending on the first letter of its name. Thus, if not e*plicitl& declared, a varia'le whose name started with one of the letters I through O was assumed to 'e an integerP otherwise it was assumed to 'e real. To allow older code to run, /ortran 01 permits implicit t%ping. However, this is poor practice, can 'e confusing, and often leads to errors. $o, we will include the -I.9-:-T N<NE statement at the start of all programs. This turns off implicit t&ping and the compiler will identif& and flag an& varia'le not defined. This help ma(e some errors, such as mis6spelling a varia'le name, significantl& easier to locate.
2 /or more information regarding real num'ers, refer to# http#55en.wi(ipedia.org5wi(i5)ealRnum'ers /or more information regarding comple* num'ers, refer to# http#55en.wi(ipedia.org5wi(i5)ealRnum'ers ! /or more information regarding characters, refer to# http#55en.wi(ipedia.org5wi(i5:haracterR3computing4 1 /or more infromation regarding strings, refer to# http#55en.wi(ipedia.org5wi(i5$tringR3computerRscience4 D /or more information regarding logicals, refer to# http#55en.wi(ipedia.org5wi(i5=ooleanRdataRt&pe
$.! #eclarations
/ortran varia'les must 'e declared 'efore e*ecuta'le statements. This section provides an introduction to how varia'les are declared.
4.3.1
Declaring )ariables
;eclaring varia'les formall& defines the data t&pe of each varia'le and sets aside a memor& location. This is performed '& a t&pe declaration statement in the form of#
<type> :: <list of variable names>
The t&pe must 'e one of the predefined data t&pes 3integer, real, comple*, character, logical4. <utlined in the previous section. ;eclarations are placed in the 'eginning of the program 3after the program statement4. /or e*ample, to define an integer varia'le toda%,
integer :: today
+dditional e*amples include#

integer real :: complex logical :: today, tomorrow, yesterday ans2 :: z :: answer
The declarations can 'e entered in an& order. +dditional information regarding character varia'les is provided in a later chapter.
4.3.2
)ariable Ranges
The computer has a predefined amount of space that can 'e used for each varia'le. This directl& impacts the si?e, or range, of the num'er that can 'e represented. /or e*ample, an integer value can range 'etween V2,1!A,!B ,D!B and O2,1!A,!B ,D!A. /ortunatel&, this is
large enough for most purposes. The range for real values is more comple*. The range is appro*imatel& 1.A 10 0B which supports a'out 11 digits of precision.
4.3.3
0ype Chec1ing
The varia'le t&pe declaration is enforced '& the compiler. /or e*ample, if a varia'le is declared as an integer, onl& an integer value 3a whole num'er4 is allowed to 'e assigned to that varia'le. +ttempting to assign a value of 1.A1 to an integer varia'le will generate an error. This restriction is related to the fact that the internal representations for various t&pes are ver& different and not directl& compati'le. The compiler can sometimes recogni?e a t&pe mismatch and implicitl& 3automaticall&4 perform a conversion. -f this is done automaticall&, it is not alwa&s clear and could lead to errors. +s such, it is generall& considered poor programming practice.
1!
:hapter ! M /ortran 01 C =asic Elements :onversions 'etween t&pes should 'e performed e*plicitl&. 9ater chapters provide specific e*amples of how this can 'e accomplished. 8hen initiall& learning to program, this ma& seem @uite anno&ing. However, this t&pe mismatch can cause su'tle and difficult to find errors.
4.3.4
,nitialization
-t is possi'le to declare a varia'le and set its initial value at the same time. This initiali?ation is not re@uired, 'ut can sometime 'e convenient. /or e*ample, to define an integer varia'le todaysdate and set it to the 11th of the month#
integer :: todaysdate=15

integer :: todaysday=15, tomorrow=16, yesterday=14 real :: ave = 5.5
$paces or no spaces are allowed 'etween the varia'le name. The varia'le declaration ma& or ma& not include an e@ual signs 3for initiali?ation4. :omma7s are used to separate multiple varia'le declarations on the same line. Faria'les initiali?ed at declaration can 'e changed later in the program as needed.
4.3.-
Constants
+ constant is a varia'le that can not 'e changed during program e*ecution. /or e*ample, a program might declare a varia'le for > and set it to .1!110. -t is unli(el& that a program would need to change the value for >. The parameter @ualifier will declare the varia'le as a constant, set the initial value, and not allow that initial value to 'e altered during the program e*ecution. /or e*ample, the declarations#
real, parameter :: pi = 3.14159 integer, parameter :: width = 1280
will set the varia'le pi to .1!110 and width to 12B0 and ensure that the& can not 'e changed while the program is e*ecuting.
$.$ Comments
:omments are information for the programmer and are not read '& the :.U. -n general, comments t&picall& include information a'out the program. /or e*ample, a comment might include the last modification date, programmer name, and details a'out the update. /or programming assignments, the comments might include the programmer name, assignment num'er, and a description of the program.
$.5 Continuation Lines

+ statement must start on a new line. -f a statement is too long to fit on a line, it can 'e continued on the ne*t line with an ampersand 37X74. Even shorter lines can 'e split and continued on multiple lines for more reada'le formatting. 11
:hapter ! K /ortran 01 C =asic Elements /or e*ample,

A = 174.5 * year + count / 100.0 &
-s e@uivalent to the following

A = 174.5 * year + count / 100.0
Note that the 7X7 is not part of the statement.
4.-.1
"#ample
The following trivial program illustrates the program formatting re@uirements and varia'le declarations.
! Example Program program example1 implicit none integer :: radius, diameter integer :: height=100, width=150 real :: area, perimeter real :: length = 123.5, distance=413.761 real, parameter :: pi = 3.14159 write (*,*) "Hello World" end program example1
-n this e*ample, a series of varia'les are defined 3as e*amples4 'ut not used. The following chapters will address how to use the varia'les to perform calculations and displa& results.
$.0 #eclarations4 ,xtended 'i(e 3ariables

The si?e or range of a num'er that can 'e held in a /ortran varia'le is limited. $pecial declarations can 'e used to provide varia'les with e*tended or larger ranges.
4.&.1
,ntegers
+s previousl& noted, the range of an integer value can range 'etween V2,1!A,!B ,D!B and O2,1!A,!B ,D!A. -n the unli(el& event that a larger range is re@uired, a special declaration can 'e used to e*tend the range. The ?ind specifier is used with the integer declaration.
1D
:hapter ! M /ortran 01 C =asic Elements /or e*ample, to declare a varia'le bignum with an e*tended range, the integer declaration would 'e as follows#
integer(kind=8) :: bignum
The e*tended range of integer varia'les declared with the ?ind@. is C0,22 , A2,0 D,B1!,AA1,B0B to 0,22 , A2,0 D,B1!,AA1,B0A.
4.&.2
Real
+s previousl& noted, the range is appro*imatel& 1.A 10 0B which supports a'out 11 digits of precision. -f more precision is re@uired, the ?ind specifier can 'e used. /or e*ample, to declare a varia'le rnum with an e*tended range, the integer declaration would 'e as follows#
real(kind=16) :: rnum
The e*tended precision of real varia'les declared with the ?ind@1, is appro*imatel& 1.A 10 0B which supports a'out 1 digits of precision.
$.5 ,xercises
4.2.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat are the five /ortran 01 data t&pesN 24 8hat should a /ortran varia'le name start withN 4 8hat data t&pe are each of the following num'ers 3integer or real4N !A1 10.21 1012 1.0 12 .!1D RRRRRRRRRRRR RRRRRRRRRRRR RRRRRRRRRRRR RRRRRRRRRRRR RRRRRRRRRRRR
!4 8rite the statements re@uired to declare value as an integer and count as a real. 14 8rite the statements re@uired to declare rate as an real initiali?ed to A.1. D4 8rite the statements re@uired to declare e as an real constant initiali?ed to 2.A1B2B1B .
1A
4.2.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the example1 e*ample program, compile, and e*ecute the program. 24 Update the e*ample program 3from 14 to displa& &ou name 3instead of the 7Hello 8orld7 message4.
1B
,x"ressions
This section descri'es how to form 'asic /ortran 01 e*pressions and perform arithmetic operations 3i.e., add, su'tract, multiple, divide, etc.4. E*pressions are formed using literals 3actual values4, varia'les, and operators 3i.e., A, 9, B, 0, etc.4. The previous chapter provides an e*planation of what varia'le is and a summar& of the five /ortran data t&pes.
5.1 Literals
The simplest e*pression is a direct value, referred to as a literal. $ince literals are actual values, not varia'les, the& can not 'e changed. There are various t&pes of literal constants descri'ed in the following sections, correspond to the data t&pes.
-.1.1
,nteger .iterals
1 0 -100 32767 +42
The following are some e*amples of integer constants#
+n integer must 'e a whole num'er 3with no fractional component4.
-.1.2
Real .iterals
1.0 -0.25 3.14159
The following are some e*amples of real constants#
The real num'er should include the decimal point 3i.e., the ,.24. + real num'er includes the fractional part, even if the fraction is 0. /ortran will accept a num'er with the ,.2 and no further digits. /or e*ample, 1. is the same as 1.0. +ll e*amples in this te*t will include the ,.02 to ensure clarit&.
-.1.2.1
"3Notation
/or larger real num'ers, e$notation ma& 'e useful. The e6notation means that &ou should multipl& the constant '& 10 raised to the power following the LEL. This is sometimes referred to as scientific notation.
10
:hapter 1 K E*pressions The following are some real constants using e6notation#
2.75E6 3.3333E-1
Hence, 2.A1E1 is 2.A1 101 or 2A1,000 and . one third.
E61 is
101 or 0.
or appro*imatel&
-.1.3
Comple# .iterals
+ complex constant is designated '& a pair of constants 3integer or real4, separated '& a comma and enclosed in parentheses. E*amples are#
(3.2, -4.1) (1.0, 9.9E-1)
The first num'er denotes the real part and the second the imaginar& part. +lthough a comple* num'er alwa&s consists of two elements, it is considered a single value.
-.1.4
Character .iterals
+ character constant is either a single character or a set of characters, called a string. + character is a single character enclosed in @uotes. + string consists of an ar'itrar& se@uence of characters also enclosed in @uotes. $ome e*amples include#
"X" "Hello World" "Good bye cruel world!" "Have a nice day"
:haracter and string constants 3enclosed with @uotes4 are case sensitive. $o, character ,J2 3upper6 case4 is not the same as ,*2 3lower6case4. + pro'lem arises if &ou want to have a @uote in the string itself. + dou'le @uote will 'e interpreted as a single within a string. The two @uotes must 'e together 3no spaces 'etween4. /or e*ample, the string#
"He said ""wow"" when he heard"
8ould 'e displa&ed as

"He said "wow" when he heard"
The dou'le6@uote is sometimes referred to as an escape character. $trings and characters must 'e associated with the character data t&pe.
20
:hapter 1 M E*pressions
-.1.-
.ogical Constants
.true. .false.
The fifth t&pe is the logical constant. These can onl& have one of two values#
The dots enclosing the true and false are re@uired.
5. %rithmetic &"erations
This section summari?es the 'asic arithmetic operations.
-.2.1
4ssignment
-n programming, assignment is the term for setting a varia'le e@ual to some value. +ssignment is performed with an e@ual 3@4 sign. The general form is#
variable = expression
The e*pression ma& 'e a literal, varia'le, an arithmetic formula, or com'ination of each. <nl& one assignment to a single varia'le can 'e made per line. /or e*ample, to declare the varia'le answer1 as a real value,
real :: answer1
and to set it e@ual to 2.A1B2B1B , it would 'e#

answer1 = 2.71828183
The value for answer1 can 'e changed as often as needed. However, it can onl& hold one value at a time.
-.2.2
4''ition
The /ortran addition operation is specified with a plus sign 3O4. /or e*ample, to declare the varia'les, mysum, number1, number2, and number3,
integer :: mysum, number1=4, number2=5, number3=3
and calculate the sum,

mysum = number1 + number2
which will set the varia'le mysum to 0 in this e*ample. The data t&pes of the varia'les, integer in this e*ample, should 'e the same. Iultiple varia'les can 'e added on one line. The line can also include literal values. /or e*ample,
mysum = number1 + number2 + number3 + 2
which will set the varia'le mysum varia'le to 1!. +dditionall&, it will over6write the previous value of 0. 21
:hapter 1 K E*pressions
-.2.3
ubtraction
The /ortran su'traction operation is specified with a minus sign 364. /or e*ample, to declare the varia'les, ans, value1, value2, and value3,
real :: ans, value1=4.5, value2=2.5, value3=1.0
and calculate the difference,

ans = value1 value2
which will set the varia'le ans to 2.0. The data t&pes of the varia'les, real in this e*ample, should 'e the same. Iultiple varia'les can 'e su'tracted on one line. The line can also include literal values. /or e*ample,
ans = value1 - value2 value3
which will set the varia'le ans to 1.0. +dditionall&, it will over6write the previous value of 2.0.
-.2.4
5ultiplication
The /ortran multiplication operation is specified with an asteris( 3Y4. /or e*ample, to declare the varia'les, ans, value1, value2, and value3,
and calculate the product,

ans = value1 * value2
which will set the varia'le ans to 0.0. The data t&pes of the varia'les, real in this e*ample, should 'e the same. Iultiple varia'les can 'e multiplied on one line. The line can also include literal values. /or e*ample,
ans = value1 * value2 * 2.0 * value3
which will set the varia'le ans to 2A.0. +dditionall&, it will over6write the previous value of 0.0.
-.2.-
Di6ision
The /ortran division operation is specified with a slash s&m'ol 354. /or e*ample, to declare the varia'les, ans, value1, value2, and value3,
and calculate the @uotient,

ans = value1 / value2
which will set the varia'le ans to !.0. The data t&pes of the varia'les, real in this e*ample, should 'e the same. Iultiple varia'les can 'e divided on one line.
22
:hapter 1 M E*pressions /or e*ample,

ans = value1 / value2 / value3
which will set the varia'le ans to 2.0. +dditionall&, it will over6write the previous value of !.0.
-.2.&
"#ponentiation
E*ponentiation means ,raise to the power of2. /or e*ample, 2 to the power of , or 2 is 32 Y 2 Y 24 which is B. The /ortran e*ponentiation operation is specified with a dou'le asteris(s 3BB4. /or e*ample, to declare the varia'les, ans and 'alue1,
real :: ans, value1=2.0
and calculate the e*ponentiation,

ans = value1 ** 3
which will set the varia'le ans to B.0. The data t&pes of the varia'les, real in this e*ample, should 'e the same.
5.! &rder of &"erations

/ortran follows the standard mathematical order of operations or precedence of operations. That is, multiplication and division are performed 'efore addition and su'traction. /urther, in accordance with mathematical standards, the e*ponentiation operation is performed 'efore multiplication and division. The following ta'le provides a partial summar& of the 'asic /ortran 01 precedence levels# -recedence /eve* 1st 2nd
rd
Operator 9 BB B A 0 9
Operation unar& 6 e*ponentiation multiplication and division addition and su'traction
!th
/or operations of the same precedence level, the e*pression is evaluated left to right. .arentheses ma& 'e used to change the order of evaluation as necessar&. /or e*ample, declaring the varia'les ans1, ans2, num1, num2, and num3.
integer :: ans1, ans2, num1=20, num2=50, num3=10
and calculating the ans1 and ans2, as follows#

ans1 = num1 + num2 * num3 ans2 = (num1 + num2) * num3
will set to ans1 to 120 and ans2 to A00 3'oth integers4.
5.$ Intrinsic Functions

-ntrinsic functions are standard 'uilt6in functions that are provided '& /ortran. These include a rich set of standard functions, including the t&pical mathematical standard functions. -ntrinsic functions can 'e used in e*pressions as needed. Iost intrinsic functions accept one or more arguments as input and return a single value.
-.4.1
5athematical ,ntrinsic %unctions
The intrinsic or 'uilt6in functions include the standard mathematical functions such as sine, cosine, tangent, and s@uare root. /or e*ample, the cosine of > is 61.0. ;eclaring and initiali?ing the varia'les x and pi as follows,
real :: z real, parameter :: pi = 3.14159
and then performing the calculation of the cosine the varia'le pi as follows,
z = cos(pi)
which will set z to 61.0. The varia'le pi is the input argument.
-.4.2
Con6ersion %unctions
<ther intrinsic functions include functions to change the t&pe of varia'les or values. The 'asic conversion functions are as follows# %unction real3Zinteger argument[4 int3Zreal argument[4 nint3Zreal argument[4 E+p*anation :onvert the Zinteger argument[ to a real value :onvert the Zreal argument[ to an integer, truncates the fractional portion :onvert the Zreal argument[ to an integer, rounds the fractional portion
/or e*ample, given the following varia'le declarations,

integer :: inum1=10, inum2, inum3 real :: rnum1, rnum2 = 4.8
and calculate the rnum1, inum2 and inum3,

rnum1 = real(inum1) inum2 = int(rnum2) inum3 = int(rnum3)
which will set to rnum1 to 10.0, inum2 to !, and inum3 to 1. 2!
:hapter 1 M E*pressions
-.4.3
ummary
%unction :<$384 -NT3+4 I<;3)1,)24 N-NT3J4 )E+93+4 $-N384 $>)T384 T+N3J4 Description )eturns real cosine of real argument 8 in radians. :onverts real argument + to integer, truncating 3real part4 towards ?ero. )eturns remainder after division of )1 on division '& )2. )esult, )1 and )2 should 'e all integer or all real t&pes. )eturns the nearest integer to real value J 3thus rounding up or down as appropriate4. :onverts integer argument + to real. )eturns real sine of real argument 8 in radians. )eturns the real s@uare root of real argument 8P 8 must 'e positive. )eturns the real tangent of real argument J in radians.
+ summar& of some of the more common intrinsic functions include#
+ more complete list of intrinsic functions in located in +ppendi* ;.
5.5 6ixed 6ode

-n general, mathematical operations should 'e performed on varia'les of the same t&pe. 8hen 'oth integer and real values or varia'les are used in the same statement, it is called mi*ed mode. )eal and integer operations#
1/2 = 0 1.0 + 1/4 = 1.0 1.0 + 1.0/4 = 1.25
+n& integers values are converted to real onl& when mi*ed6mode is encountered on the same operation t&pe. :onversion ma& also occur on assignment. Une*pected conversions can cause pro'lems when calculating values. -n order to avoid such pro'lems, it is strongl& recommended to not use mi*ed6mode. There are a series of rules associated with mi*ed6 mode operations. -n some circumstances, these rules can 'e confusing. /or simplicit&, those rules are not covered in this te*t. -f it is necessar& to perform calculations with different data t&pes, such as integers and reals, the intrinsic or 'uilt6in conversion functions should 'e used to ensure correct and predicta'le results. This also allows the programming greater control of when t&pes are converted. -n ver& comple* calculations, this would help ensure clarit& and address precision issues. /urther recommendations to address highl& precise calculations are not addressed in this te*t.
21
5.0 ,xam"les
=elow is an e*ample program that calculates velocit& 'ased on acceleration and time. The program declares the appropriate varia'les and calculate the velocit&.
program findvelocity ! Program to calculate the velocity from the ! acceleration and time ! Declare variables implicit none real :: velocity, acceleration = 128.0 real :: time = 8.0 ! Display initial header write (*,*) "Velocity Calculation Program" write (*,*) ! Calculate the velocity velocity = acceleration * time write (*,*) "Velocity = ", velocity end program findvelocity
+dditional information regarding how to perform input and output in the ne*t chapter. The comments are not re@uired, 'ut help ma(e the program easier to read and understand.
5.5 ,xercises
=elow are some @ui? @uestions and proEect suggestion 'ased on this chapter.
-.2.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat is the assignment operatorN 24 8hat is the e*ponentiation operatorN 4 How can an integer varia'le 'e converted to a real valueN !4 How can an real varia'le 'e converted to a integer valueN 14 8hat are the two logical constantsN D4 9ist three intrinsic functions.
2D
:hapter 1 M E*pressions A4 8rite the single /ortran statement for each of the following formulas. "ou ma& assume all varia'les are alread& declared as real values. +dditionall&, &ou ma& assume the varia'le .- is set as a parameter and initiali?ed to .1!110. x1 =
( , ) (!a +!b + c ) c
2 2 2
x2 =
2a cos ( b ) sin ( b ) c
x3 =
b + ( b 2 4 a c ) 2a
-.2.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the velocit& program, compile, and e*ecute the program. :hange the declared values, compile, and e*ecute the modified program. Ferif& the results of 'oth e*ecutions with a calculator. 24 8rite a program to calculate and displa& the difference 'etween time as read from a sundial and a cloc(. The difference can 'e calculated with the ,e@uation of time2 which is: b = 2 ( n .1) / !,4 e = &..$ sin ( 23) $.'! cos ( b ) 1.' sin ( b ) 8here, n is the da& num'er. /or e*ample, n U 1 for Januar& 1, n U 2 for Januar& 2, and so on. The program should read the value for n 316 D!4 from the user and an integer. The program should perform the appropriate t&pe conversions, perform the re@uired calculations, and displa& the n, b, and final e values. Test the program on a series of different values.
2A
2B
'im"le In"ut and &ut"ut
$imple, unstructured, input and output can 'e performed with the "rite and read statements as e*plained in the following sections. -n a later chapter, a more structured approach will 'e presented in later sections.
0.1 &ut"ut 1 Write

+s noted from the first program, simple output can 'e performed '& using the a "rite statement. /or e*ample#
write (*,*) "Hello World"
8hich will send the message, referred to as a string, Ce**o 7or*d to the screen. The first ,Y2 means the default output device, which is the screen or monitor. The second ,Y2 refers to the 7free format7. Thus, the ,(*,*)2 means to send it to the screen in 7free format7. The free format allows the /ortran compiler to determine the appropriate format for the information 'eing displa&ed. This is eas&, especiall& when first getting started, 'ut does not allow the program much control over how the output will 'e formatted or displa&ed on the screen. +dditionall&, the value held '& declared varia'les can 'e displa&ed. /or e*ample, to declare the varia'les num1, num2, and num3.
integer :: num1=20, num2=50, num3=10
the write statement to displa& num1 would 'e,

write (*,*) num1
The free format allows the /ortran compiler to determine the appropriate output format for the information 'eing displa&ed. + write statement with no string or varia'les,
write (*,*) num1
8ill displa& a 'lan( line. Iultiple varia'les and strings can 'e displa&ed with one write statement. /or e*ample, using the previous declarations,
write (*,*) "Number 1 = ", num1, "Number 2 = ", num2
The information inside the @uotes is displa&ed as is, including capitali?ation and an& spelling errors. 8hen the @uotes are not used, it is interpreted as a varia'le. -f the varia'le is not declared, a compiler error will 'e generated. The value assigned to each varia'le will 'e displa&ed. + value must have 'e assigned to the varia'le prior to attempting to displa&.
20
:hapter D K $imple -nput and <utput
&.1.1
!utput $ Print
-n addition to the write statement, a print statement can 'e used. The print statement will send output onl& to the screen. Thus it is a more restrictive form of the write statement. +s with the write statement, multiple varia'les and strings can 'e displa&ed with one print statement. /or e*ample, using the previous declarations,
print *,"Number 1 = ", num1, "Number 2 = ", num2
The information inside the @uotes is displa&ed as is, including capitali?ation and an& spelling errors. 8hen the @uotes are not used, it is interpreted as a varia'le. -f the varia'le is not declared, an error will 'e generated. -f the varia'le is defined, the value assigned to that varia'le will 'e displa&ed. -n general, all e*amples will use the write statement.
0. In"ut 1 +ead
To o'tain information from the user, a read statement is used. /or e*ample, to declare the varia'les num1, num2,
integer :: ans1, ans2
then read a value for ans1 from the user,

read (*,*) ans1
8hich will read a num'er from the user entered on the (e&'oard into the varia'le ans1. The 3Y,Y4 means to send it to read the information in 7free format7. The free format allows the /ortran compiler to determine the appropriate format for the information 'eing read. Iultiple varia'les can 'e read with one write statement. /or e*ample, using the previous declarations,
read (*,*) ans1, ans2
will read two values from the user into the varia'les ans1 and ans2. $ince the read is using free format, two num'ers will 'e re@uired. The num'ers can 'e entered on the same line with one more more spaces 'etween them or on separate lines. The read will wait until two num'ers are entered. 8hen reading information from the user, it is usuall& necessar& to provide a prompt in order to ensure that the user understands that input is 'eing re@uested '& the program. + suita'le write statement with an appropriate string, followed '& a read statement will ensure that the user is notified that input is 'eing re@uested. /or e*ample, to read a date, a program might re@uest month, date, and &ear as three separate varia'les. Given the following declarations,
integer :: month, date, year
the program might prompt for and read the data in the following manner,
write (*,*) "Enter date (month, date, and year)" read (*,*) month, date, year
:hapter D M $imple -nput and <utput $ince the program is re@uesting three integers, three integers must 'e entered 'efore the program continues. The three num'ers ma& 'e entered on one line with a single space 'etween them, with multiple spaces or ta' 'etween them, or even on three different lines as in the following e*amples#
Enter date (month, date, and year) 10 17 2009 Enter date (month, date, and year) 10 17 2009 Enter date (month, date, and year) 10 17 2009
The t&pe of num'er re@uested here is an integer, so integers should 'e entered. .roviding a real num'er or character 3e.g., letter4 would generate an error. 9ater chapters will address how to deal with such errors.
0.! ,xam"le
=elow is an e*ample program that calculates the area of a circle. The program will declare the appropriate varia'les, read the radius, calculate the circle area, and displa& the result.
Program circle ! Program to calculate the area of a circle ! Declare variables implicit none real :: radius, area real, parameter :: pi = 3.14159 ! Display initial header and blank line write (*,*) "Circle Area Calculation Program" write (*,*) ! Prompt for and read the radius write (*,*) "Enter Circle Radius" read (*,*) radius ! Calculate the circle area area = pi * radius**2 ! Display result write (*,*) "Circle Area: end program circle ", area
:hapter D K $imple -nput and <utput The comments are not re@uired, 'ut help ma(e the program easier to read and understand. -f the program does not wor( at first, the comments can aid in determining the pro'lem.
0.$ ,xercises
&.4.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat does the (*,*) meanN 24 8hat is the statement to output a message ,.rogramming is /un\2 4 8hat are the statements to declare and read the value for a persons age in &ears.
&.4.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the circle area program, compile and e*ecute the program. Test the program on several sets of input. 24 Iodif& the circle area program to re@uest a circle diameter. The formula for circler area must 'e adEusted accordingl&. )ecall that radius U diameter divided '& two. Test the program on several sets of input. 4 T&pe in the velocit& program from the previous chapter and update to prompt for and re@uest input for the acceleration and time, and then displa& the results. Test the program on several sets of input. !4 8rite a /ortran program to read the length of the a and b sides of a right triangle and compute the perimeter length. The program should prompt for input and displa& the values for sides a, b, c, and the perimeter with appropriate headings. )ecall that# c=
a2+ b2
perimeter = a + b + c Test the program on several sets of input. '
:hapter D M $imple -nput and <utput
14 8rite a /ortran program compute geometric information for a Gite. The program should read the a, c and p lengths and compute the ! length. The program should c displa& an appropriate prompt, read the values, compute the answer, and displa& the original input and the final result. @ p )ecall that# a p2 p2 ! = ( a2 ) ( c2 ) 4 4
Test the program on several sets of input.
:hapter D K $imple -nput and <utput
Program #e)elo"ment

8riting or developing programs is easier when following a clear methodolog&. The main steps in the methodolog& are# Understand the .ro'lem :reate the +lgorithm ;evelop the .rogram Test5;e'ug the .rogram
To help demonstrate this process in detail, these steps will 'e applied to a simple pro'lem to calculate and displa& the period of a pendulum. +s additional e*amples are presented in later chapters, the& will 'e e*plained and presented using this methodolog&.
5.1 7nderstand the Problem

=efore attempting to create a solution, it is important to understand the pro'lem. Ensuring a complete understanding of the pro'lem can help reduce errors. The first step is to understand the what is re@uired and the applica'le input information. -n this e*ample, the formula for the period of a pendulum is#
"eriod = 2 8here# g U U # U $ U
(
# g
1+
1 $ sin 2 4 2
( ))
] 9
0B0 cm5sec2 .1!110 .endulum length 3cm4 +ngle of displacement 3degree4
=oth g 3gravit&4 and should 'e declared as a constants. The formula is a simplified version of the more general case. +s such, for ver& large, ver& small, or ?ero angle values the formula will not provide accurate results. /or this e*ample, that is accepta'le. +s shown, the pendulum is attached to a fi*ed point, and set into motion '& displacing the pendulum '& an angle, $, as shown in the diagram. The program must define the constants for g and , declare the varia'les, displa& appropriate prompts, read the values for # and $ then calculate and displa& the original input and the period of the pendulum with the given length and angle of displacement.
:hapter A K .rogram ;evelopment
5. Create the %lgorithm

The algorithm is the name for the ordered se@uence of steps involved in solving the pro'lem. <nce the program is understood, a series of steps can 'e developed to solve that pro'lem. There can 'e multiple correct solutions to a given pro'lem. The process for creating an algorithm can 'e different for different people. -n general, some time should 'e devoted to thin(ing a'out a possi'le solution. This ma& involve wor(ing on some possi'le solution on a scratch piece of paper. <nce a possi'le solution is selected, that solution can 'e developed into an algorithm. The algorithm can 'e written down, reviewed, and refined. This algorithm is the outline of the program. /or this pro'lem, the varia'les and constants must 'e declared, the applica'le headers and prompts displa&ed, and the values for # and $ read from the user. Then the period can 'e calculated 'ased on the provided formula and the results displa&ed. /ormali?ing this, the following steps can 'e developed and written down as follows#
! ! ! ! ! ! ! declare variables real constants -> gravity, pi reals -> angle, length display initial header prompt for and read the length and angle values calculate the period display the results
8hile this is a fairl& straightforward algorithm, more comple* pro'lems would re@uire more e*tensive algorithms. E*amples in later chapters will include more comple* programs. /or convenience, the steps are written a program comments. This will allow the addition of the code to the 'asic algorithm.
5.! #e)elo" the Program

=ased on the algorithm, the following program can 'e created.
program period ! Program to calculate the period of a pendulum ! declare variables ! real constants -> gravity, pi ! reals -> angle, length implicit none real :: angle, length, pperiod real, parameter :: gravity=980.0, pi=3.14159 ! display initial header write (*,*) "Pendulum Period Calculation Program" write (*,*)
:hapter A M .rogram ;evelopment

! prompt for and read the length and angle values write (*,*) "Enter Length and Angle values:" read (*,*) length, angle ! calculate the period pperiod = 2.0 * pi * sqrt(length/gravity) * & ( 1.0 + 1.0/4.0 * sin(angle/2.0)**2 ) ! display the results write(*,*) "The period is:", pperiod end program period
The indentation is not re@uired, 'ut helps ma(e the program easier to read. Note that the ,22, ,12, and ,!2 in the algorithm are entered as 2.0, 1.0, and !.0 to ensure consistent data t&ping 3i.e., all reals4. -f the 1 over ! is entered as ,15!2 instead of ,1.05!.02, it 'e incorrect since ,15!2 would provide a result of 0 3since this would 'e integer division4.
5.$ Test8#ebug the Program

<nce the program is written, testing should 'e performed to ensure that the program wor(s. The testing will 'e 'ased on the specific parameters of the program. -n this e*ample, each of the three possi'le values for the discriminant should 'e tested.
C:\mydir> period Pendulum Period Calculation Program Enter Length and Angle values: 120.0 15.0 The Period is: K:\mydir> 2.682276
+s 'efore, input t&ped '& the user is shown in 'old. /or this program, the results can 'e verified with a calculator. + series of different values should 'e used for testing. -f the program does not wor(, the program comments provide a chec(list of steps and can 'e used to help de'ug the program.
2.4.1
"rror 0erminology
-n case the program does not wor(, it helps to understand some 'asic terminolog& a'out where or what the error might 'e.
2.4.1.1
Compiler "rror
:ompiler errors are generated when the program is compiled. This means that the compiler does not understand the instructions. The compiler will provide a list of errors and the line num'er the of each A
:hapter A K .rogram ;evelopment error. -t is recommended to address the errors from the top down. )esolving an error at the top can clear multiple errors further down. T&pical compiler errors include misspelling a statement and5or omitting a varia'le declaration. /or e*ample, if the correct /ortran statement ,write 3Y,Y42 is entered incorrectl& as ,wrote 3Y,Y42, an error will 'e generated. -n this case, the compiler error displa&ed will appear as follows#
c:\mydir> gfortran -o period period.f95 period.f95:13.1: wrote (*,*) 1 Error: Unclassifiable statement at (1)
The first digit, 1 in this e*ample, represents the line num'er where the error occurred. Using a te*t editor that displa&s line num'ers, the statement that caused the error can 'e @uic(l& found and corrected. -f the declaration for the varia'le length is omitted, the error would appear as follows#
c:\mydir> gfortran -o period period.f95 period.f95:17.18: read (*,*) length, angle 1 Error: Symbol 'length' at (1) has no IMPLICIT type
-n this case, the error is shown on line 1B 3first digit after the ,#24. However, the actual error is that the varia'le length is not declared. Each error should 'e reviewed and evaluated.
2.4.1.2
Run3time "rror
+ run6time error is something that causes the program to crash. /or e*ample, if the a num'er is re@uested from the user and a letter is entered, that can cause occur. /or e*ample, the period program e*pects two real num'ers to 'e entered. -f the user enters letters, * and &, in this e*ample, an error will 'e generated during the e*ecution of the program as follows#
c:\mydir> period Pendulum Period Calculation Program Enter Length and Angle values: x y At line 17 of file period.f95 (unit = 5, file = 'stdin') Fortran runtime error: Bad real number in item 1 of list input
The program was e*pecting numeric values and letters were provided. $ince letters are not meaningful B
:hapter A M .rogram ;evelopment in this conte*t, it is an error and the program ,crashes2 or stops with an error message. 9ater chapters will provide additional information on how to deal with such errors. Until then, proving the correct data t&pe will avoid this (ind of error.
2.4.1.3
.ogic "rror
+ logic error is when the program e*ecutes, 'ut does not produce the correct result. /or e*ample, coding a provided formula incorrectl& or attempting to computer the average of a series of num'ers 'efore calculating the sum. /or e*ample, the correct formula for the period of a pendulum is as follows#
pperiod = 2.0 * pi * sqrt(length/gravity) * & ( 1.0 + 1.0/4.0 * sin(angle/2.0)**2 )
-f the formula is t&ped incorrectl& or incompletel& as follows#

pperiod = 2.0 * pi * sqrt(length/gravity) * & ( 1.0 + 1/4 * sin(angle/2.0)**2 )
The 1 over ! is entered as ,15!2 which are interpreted as integers. +s integers, ,15!2 results in 0. The compiler will accept this, perform the calculations, and provide an incorrect result. The program would compile and e*ecute as follows.
c:\mydir> period Pendulum Period Calculation Program Enter Length and Angle values: 120.0 15.0 The period is: 2.198655
However, an incorrect answer would 'e generated as shown. This is wh& testing the program is re@uired. 9ogic errors can 'e the most difficult to find. <ne of the 'est wa&s to handle logic errors is to avoid them '& careful developing the algorithm and writing the code. -f the program has a logic error, one wa& to find the error is to displa& intermediate values. /urther information will 'e provided in later chapters regarding advice on finding logic errors.
5.5 ,xercises
2.-.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat are the four program development stepsN
:hapter A K .rogram ;evelopment 24 8hat are the three t&pes of errorsN 4 -f a program to compute the area of a rectangle uses a formula, height ^ height ^ width, what t&pe of error would this 'eN !4 .rovide an e*ample of that would generate a compiler error.
2.-.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the pendulum period calculation program, compile, and e*ecute the program. Test the program using several different input values. 24 :reate a program to prompt for and read the circle area from the user and calculate the circumference of a circle using the following formula#
circumference = 2
%ircle&rea
Test the program using several different input values. 4 :reate a program to prompt for and read the radius of a sphere from the user and calculate the surface area of the sphere using the following formula# sphere 'urface &rea = 4 r 2 Test the program using several different input values. !4 :reate a program to prompt for and read the radius of a sphere from the user and calculate the sphere volume using the following formula#
sphere(olume = ( 4 / ! ) r
!
Test the program using several different input values.
!0
'election 'tatements
8hen writing a program, it ma& 'e necessar& to ta(e some action 'ased on the outcome of comparing the values of some varia'les. +ll programming languages have some facilit& for decision6ma(ing. That is, doing one thing if some condition is true and 3optionall&4 doing something else if it is not. /ortran -/ statements and5or :+$E statements are used to allow a program ma(es decisions.
9.1 +elational ,x"ressions

The first step is to compare two values, often contained in varia'les. The wa& two values are compared is with relational operators. The varia'les are often referred to as operands. )elational or logical operators are used 'etween varia'les or operands of similar t&pes. That is real to real, integer to integer, logical to logical, and character5string to character5string. The 'asic relational operators are# 5e*ationa* Operation Greater than Greater than or e@ual 9ess than 9ess than or e@ual E@ual to Not e@ual to 5e*ationa* Operator Dnorma*E F F@ G G@ @@ 0@ 5e*ationa* Operator Da*ternateE .gt. .ge. .*t. .*e. .eH. .ne.
The normal form will 'e used for e*amples in this te*t. However, the alternate form ma& 'e used at an& time. The alternate forms ma& 'e re@uired to support older /ortran programs. + relational operation is used to form a relational e*pression. The result of a relational e*pression must alwa&s result in either a true or &alse result. The ,@@2 3two e@ual signs4 is used to compare. The ,@2 3single e@ual4 is used for assignment 3setting a varia'le4. The ,@@2 does not change an& values, while the ,@2 does. /or e*ample, given the declaration of,
integer :: gameLives
it might 'e useful to (now if the current value of game#ives is greater than 0.
!1
:hapter B K $election $tatements -n this case, the logical or relational e*pression would 'e,
(gamelives > 0)
8hich will result in a true or &alse result 'ased on the value of the varia'le gamelives.
9. Logical &"erators
9ogical operators are used 'etween two logical varia'les or two logical e*pressions. The& are# /ogica* Operator .and. .or. .not. E+p*anation the result is true if both operands are true the result is true if either operand is true logical negate 3if true, ma(es false and if false, ma(es true4
9ogical operators are used to com'ine relational operations as needed. /or e*ample, given the declaration of,
integer :: gameLives, extraLives
it might 'e useful to (now if the current value of game#ives is greater than 0. -n this case, the relational operation would 'e,
( (gameLives == 0) .and. (extraLives == 0) )
which will result in a true or &alse result. $ince the +N; logical operation is used, the final result will 'e true onl& if 'oth logical e*pressions are true. +nother wa& of chec( the status might 'e,
( (gameLives > 0) .or. (extraLives > 0) )
which still results in a true or &alse result. However, since the or logical operation is used, the final result will 'e true if either logical e*pressions is true. The relational operators have higher precedence than logical operators. + logical e*pression is a relational e*pression or a com'ination of relational e*pressions and logical operators.
9.! IF 'tatements
-/ statements are used to perform different computations or actions 'ased on the result of a logical e*pression 3which evaluates to true or false4. There are a series of different forms of the 'asic -/ statement. Each of the forms is e*plained in the following sections.
!2
:hapter B M $election $tatements
7.3.1
,% 0/"N tatement
The -/ statement, using the relational operators, is how programs ma(e decisions. The general format for an -/ statement is as follows#
if ( <relational expression> ) then <fortran statement(s)> end if
8here the Zfortran statements[ ma& include one or more valid /ortran statements. /or e*ample, given the declaration of,
'ased on the current value of gamelives is, a reasona'le -/ statement might 'e#
if ( gameLives == 0 ) then write (*,*) "Game Over." write (*,*) "Please try again." end if
8hich will displa& the message ,Game <ver2 if the value of gamelives is less than or e@ual to 0.
7.3.1.1
,% 0/"N tatement8 imple %orm

if ( <relational expression> ) <fortran statement>
+dditionall&, another form of the -/ statement includes
-n this form, a single statement is e*ecuted if the relational e*pression evaluates to true. The previous e*ample might 'e written as
if ( gameLives == 0 ) write (*,*) "Game Over."
-n this form, no ,then2 or ,end if2 are re@uired. However, onl& one statement can 'e e*ecuted.
7.3.2
,% 0/"N ". " tatement
The -/ THEN E9$E statement e*pands the 'asic -/ statement to also allow a series of statements to 'e performed if the logical e*pression evaluates to &alse. The general format for an -/ THEN E9$E statement is as follows#
if ( <relational expression> ) then <fortran statement(s)> else <fortran statement(s)> end if
8here the Zfortran statements[ ma& include one or more valid /ortran statements.
:hapter B K $election $tatements /or e*ample, given the declaration of,

'ased on the current value of game#ives is, a reasona'le -/ THEN E9$E statement might 'e#
if ( gameLives > 0 ) then write (*,*) "Still Alive, Keep Going!" else write (*,*) "Extra Life Granted." gamesLives = 1 end if
8hich will displa& the message ,$till +live, Geep Going2 if the value of game#ives is greater than 0 and displa& the message ,E*tra 9ife Granted2 if the value of game#ives is less than 0.
7.3.3
,% 0/"N ". " ,% tatement
The -/ THEN E9$E -/ statement e*pands the 'asic -/ statement to also allow a series of -/ statements to 'e performed in a series. The general format for an -/ THEN E9$E -/ statement is as follows#
if ( <relational expression> ) then <fortran statement(s)> else if ( <relational expression> ) then <fortran statement(s)> else <fortran statement(s)> end if
8here the Zfortran statements[ ma& include one or more valid /ortran statements. /or e*ample, given the declaration of,
'ased on the current value of game#ives is, a reasona'le -/ THEN E9$E -/ statement might 'e#
if ( gameLives > 0 ) then write (*,*) "Still Alive, Keep Going!" else if ( gameLives < 0 ) write (*,*) "Sorry, game over." else write (*,*) "Extra Life Granted." gamesLives = 1 end if
8hich will displa& the message ,$till +live, Geep Going2 if the value of gamelives is greater than 0, displa& the message ,$orr&, game over2 if the value of game lives is Z 0, and displa& the message ,E*tra 9ife Granted2 if the value of gamelives is e@ual to 0.
!!
9.$ ,xam"le &ne

+s previousl& descri'ed, writing or developing programs is easier when following a methodolog&. +s the program 'ecome more comple*, using a clear methodolog& is even more important. The main steps in the methodolog& are#

Understand the .ro'lem :reate the +lgorithm ;evelop the .rogram Test5;e'ug the .rogram
To help demonstrate this process in detail, these steps will 'e applied to a familiar pro'lem as an e*ample. The e*ample pro'lem is to calculate the solution of a @uadratic e@uation in the form# a x2 + b x + c = 0 Each of the steps, as applied to this pro'lem will 'e reviewed.
7.4.1
9n'erstan' the Problem
=efore creating a solution, it is important to understand the pro'lem. Ensuring a complete understanding of the pro'lem can help reduce errors. -t is (nown that the solution to the @uadratic e@uation is as follows# x = b ( b 2 4 a c ) 2a
-n the @uadratic e@uation, the term b2 ! a c is the discriminant of the e@uation. There are three possi'le results for the discriminant as descri'ed 'elow#
-f b2 ! a c 0 then there are two distinct real roots to the @uadratic e@uation. These two solutions represent the two possi'le answers. -f the e@uation solution is graphed, the curve representing the solution will cross the x6a*is 3i.e., representing xU04 in two locations. -f b2 ! a c = 0 then there is a single, repeated root to the e@uation. -f the e@uation solution is graphed, the curve representing the solution will cross the x6a*is in one location. -f b2 ! a c 0 then there are two comple* roots to the e@uation. -f the e@uation solution is graphed, the curve representing the solution will not cross the x6a*is and this no real num'er solution. However, mathematicall& the s@uare root of a negative value will provide a comple* result. + comple* num'er includes a real component and an imaginar& component.
+ correct solution must address each of these possi'ilities. /or this pro'lem, it is appropriate to use real values.
!1
:hapter B K $election $tatements The relationship 'etween the discriminant and the t&pes of solutions 3two different solutions, one repeated solution, or no real solutions4 is summari?ed in the 'elow ta'le# -ositive Discriminant Two real solutions E*ample# * 20* Iero Discriminant <ne real solution E*ample# 2* 2 !* 2 6egative Discriminant Two comple* solutions E*ample# * 2 *
Two distinct x6intercepts )oot 1 U 60. B2 )oot 2 U 62.D1B
<ne x6intercept )oot 1 U 61.0
No x6intercept )oot U 60.1 O 0.BDD )oot U 60.1 6 0.BDD
The e*amples provided a'ove are included in the e*ample solution in the following sections.
7.4.2
Create the 4lgorithm
The algorithm is the name for the ordered se@uence of steps involved in solving the pro'lem. The varia'les must 'e defined and an initial header displa&ed. /or this pro'lem, the a, b, and c values will need to 'e read from the user. /ormali?ing this, the following steps can 'e developed.
! declare variables ! reals -> a, b, c, discriminant, root1, root2 ! display initial header ! read the a, b, and c values
Then, the discriminant can 'e calculated. =ased on the discriminant value, the appropriate set of calculations can 'e performed.
! calculate the discriminant ! if discriminant is 0,
!D

! calculate and display root ! if discriminant is >0, ! calculate and display root1 and root2 ! if discriminant is <0, ! calculate and display complex root1 and root2
/or convenience, the steps are written a program comments.
7.4.3
De6elop the Program

program quadratic ! Quadratic equation solver program ! declare variables ! reals -> a, b, c, discriminant, root1, root2 implicit none real :: a, b, c real :: discriminant, root1, root2 ! display initial header write (*,*) "Quadratic Equation Solver Program" write (*,*) "Enter A, B, and C values" ! read the a, b, and c values read (*,*) a, b, c ! calculate the discriminant discriminant = b ** 2 4.0 * a * c ! if discriminant is 0, ! calculate and display root if ( discriminant == 0 ) then root1 = -b / (2.0 * a) write(*,*) "This equation has one root:" write(*,*) "root = ", root1 end if ! if discriminant is >0, ! calculate and display root1 and root2 if ( discriminant > 0 ) then root1 = (-b + sqrt(discriminant)) / (2.0 * a) root2 = (-b - sqrt(discriminant)) / (2.0 * a) write(*,*) "This equation has two real roots:" write(*,*) "root 1 = ", root1 write(*,*) "root 2 = ", root2 end if
!A
:hapter B K $election $tatements

! if discriminant is <0, ! calculate and display complex root1 and root2 if ( discriminant < 0 ) then root1 = -b / (2.0 * a) root2 = sqrt(abs(discriminant)) / (2.0 * a) write(*,*) "This equation has a complex root:" write(*,*) "root 1 = ", root1, "+i", root2 write(*,*) "root 2 = ", root1, "-i", root2 end if end program quadratic
The indentation is not re@uired, 'ut does help ma(e the program easier to read.
7.4.4
0est:Debug the Program
<nce the program is written, testing should 'e performed to ensure that the program wor(s. The testing will 'e 'ased on the specific parameters of the program. -n this e*ample, each of the three possi'le values for the discriminant should 'e tested.
C:\mydir> quad Quadratic Equation Solver Program Enter A, B, and C values 2 4 2 This equation has one root: root = -1.0000000 C:\mydir> quad Quadratic Equation Solver Program Enter A, B, and C values 3 9 3 This equation has a complex root: root 1 = -0.38196602 root 2 = -2.6180339 C:\mydir> quad Quadratic Equation Solver Program Enter A, B, and C values 3 3 3 This equation has a complex root: root 1 = -0.50000000 +i 0.86602539 root 2 = -0.50000000 -i 0.86602539 C:\mydir>
+dditionall&, these results can 'e verified with a calculator.
!B
9.5 ',L,CT C%', 'tatement

+ $E9E:T :+$E statement, often referred to as a :+$E statement, is used to compare a given value with preselected constants and ta(e an action according to the first constant to match. + :+$E statement can 'e hand& to select 'etween a series of different possi'ilities or cases. The select case varia'le or e*pression must 'e of t&pe integer, character, or logical. + real t&pe is not allowed. =ased on the selector, a set of one or more of /ortran statements can 'e e*ecuted. The general format of the $E9E:T :+$E statement is#
select case (variable) case (selector-1) <fortran statement(s)-1> case (selector-2) <fortran statement(s)-2> . . . case (selector-n) <fortran statement(s)-n> case default <fortran statement(s)-default> end select
where Zfortran statement3s461[, Zfortran statement3s462[, Zfortran statement3s46 [, ..., Zfortran statement3s46n[ and Zfortran statement3s46default[ are se@uences of one or more e*ecuta'le statements. The selector61, selector62, selector6 , ..., and selector6n are called selector lists. Each :+$E selector list ma& contain a list and5or range of integers, character or logical constants, whose values ma& not overlap within or 'etween selectors. + selector6list is either a single or list of values, separated '& commas. Each selector list must 'e one of the following forms.
( ( ( ( value ) value-1 : value-2 ) value-1 : ) : value-2 )
where value, value61 and value62 are constants or literals. The t&pe of these constants must 'e identical to that of the selector.

The first form has onl& one value The second form means all values in the range of value61 and value62 3inclusive4. -n this form, value61 must 'e less than value62 The third form means all values that are greater than or e@ual to value61 The fourth form means all values that are less than or e@ual to value62
-n order, each selector e*pression is evaluated. -f the varia'le value is the selector or in the selector range, then the se@uence of statements in Zfortran statement3s4[ are e*ecuted. -f the result is not in an& one of the selectors, there are two possi'ilities#
!0
if :+$E ;E/+U9T is there, then the se@uence of statements in statements6;E/+U9T are e*ecuted, followed '& the statement following EN; $E9E:T if the :+$E ;E/+U9T is not there, the statement following EN; $E9E:T is e*ecuted
The constants listed in selectors must 'e uni@ue. The :+$E ;E/+U9T is optional. =ut with a :+$E ;E/+U9T, &ou are guaranteed that whatever the selector value, one of the la'els will 'e used. The place for :+$E ;E/+U9T can 'e an&where within a $E9E:T :+$E statementP however, putting it at the end would 'e more natural. /or e*ample, given the declarations,
integer :: hours24, hours12 character(2) :: ampm
the following case statement,

select case (hours24) case (0) hours12 = 12 ampm = "am" case (1:11) hours12 = hours24 ampm = "am" case (12) hours12 = hours24 ampm = "pm" case (13:23) hours12 = hours24 - 12 ampm = "pm" end select
might 'e useful for to convert 2!6hour time into 126hour time. +dditionall&, the selectors can 'e com'ined and separated '& commas. /or e*ample, given the declarations,
integer :: monthnumber, daysinmonth character(9) :: monthname
the following case statement,

select case (monthnumber) case (1,3,5,7,8,10,12) daysinmonth = 31 case (2) if (mod(year,4)==0) then daysinmonth = 29 else daysinmonth = 28 end if case (4,6,9,11) daysinmonth = 30
10
case default write (*,*) "Error, month number not valid." end select
might 'e useful to determine the num'er of da&s in a given month. The leap6&ear calculation is not complete, 'ut is ade@uate if the range of the &ear is sufficientl& limited.
9.0 ,xam"le T*o

+ t&pical pro'lem is to assign grades 'ased on a t&pical grading standard.
7.&.1
/or this e*ample, the program will assign grades using the following grade scale# + +[U00 = B0 6 B0 : A0 6 A0 ; D0 6 D0 / ZU10
The program will read three test scores, compute the average, and displa& the appropriate grade 'ased on the average.
7.&.2
The algorithm is the name for the ordered se@uence of steps involved in solving the pro'lem. /or this pro'lem, the varia'les will 'e declared and an initial header displa&ed. Then, the test1, test2, and test2 values will need to 'e read from the user.
! declare variables ! reals -> test1, test2, test3 ! integer -> testave ! display initial header ! read the test1, test2, and test3 values
Ne*t, the average can 'e calculated. The average will 'e converted to the nearest integer and, 'ased on that, the appropriate grade can 'e determined and displa&ed. /ormali?ing this, the following steps can 'e developed.
! calculate the testave and convert to integer ! determine grade ! A - >= 90 ! B - 80 to 89 ! C - 70 to 79 ! D - 60 to 69 ! F - <= 59
11
7.&.3
De6elop the Program

program grades ! declare variables implicit none real :: test1, test2, test2 integer :: testave ! display initial header write (*,*) "Grade Assignment Program" write (*,*) write (*,*) "Enter test 1, test 2 and test 3 values" ! read the test1, test2, and test2 values read (*,*) test1, test2, test3 ! calculate the average and convert to integer testave = nint ((test1 + test2 + test3)/3.0) ! determine grade ! A >= 90, B 80-89, C 70-79, D 60-69, F <= 59 select case (testave) case(90:) write (*,*) case(80:89) write (*,*) case(70:79) write (*,*) case(60:69) write (*,*) case(:59) write (*,*) end select end program grades
"Grade is: A" "Grade is: B" "Grade is: C" "Grade is: D" "Grade is: F"
The indentation is not re@uired, 'ut does help ma(e the program easier to read.
7.&.4
<nce the program is written, testing should 'e performed to ensure that the program wor(s. The testing will 'e 'ased on the specific parameters of the program.
12
:hapter B M $election $tatements -n this e*ample, each of the three possi'le values for the discriminant should 'e tested.
C:\mydir> grade Grade Assignment Program Enter test 1, test 2 and test 3 values 70 80 90 Grade is: B C:\mydir>
The program should 'e tested with a series of data items to ensure appropriate grade assignment for each grade. Test values for each grade should 'e entered for the testing.
9.5 ,xercises
7.2.1
Quiz Questions
=elow are some @ui? @uestions. 14 9ist the si* relational operatorsN 24 9ist the three 'asic logical operatorsN 4 /or each of the following, answer .true. or .=a*se. in the space provided.
boolean :: b1 = .true., b2=.false., b3=.true. integer :: i=5, j=10 ( b1 .or. b2 ) ( b1 .or. b3 ) ( b1 .and. b2 ) ( (b1 .or. b2) .and. b3 ) ( b1 .or. (b2 .and. b3) ) ( .not. ( i < j ) ) ( j < i ) ______________ ______________ ______________ ______________ ______________ ______________ ______________
!4 8rite the /ortran -/ THEN statements to displa& the message LGame <verL if the integer varia'le lives is _ to 0. "ou ma& assume the varia'le lives is alread& declared as an integer and initiali?ed.
14 8rite the /ortran -/ THEN statements to chec( the integer varia'le num and if the value is Z 0, ta(e the a'solute value of the num'er and displa& the message, Lnum was made positiveL. "ou ma& assume the varia'le num is alread& declared as an integer and initiali?ed. D4 8rite the /ortran statements to compute the formula z = x assuming the values for integer y varia'les x, y, and z are previousl& set. However, if y U 0, do not compute the formula, set z U 0, and displa& an error message, LW not calculatedL. "ou ma& assume the varia'les x, y, and z are alread& declared as an integers and initiali?ed.
A4 8rite the statements re@uire to compute the following formula using real varia'les f, x, and y. Use a single -/ THEN E9$E -/ statement. "ou ma& assume the values for f, x, and y have alread& 'een declared as real values and initiali?ed.
f ( x )= x y x y 7.2.2
if x 0.0 if x > 0.0
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the @uadratic e@uation program, compile, and e*ecute the program. .rovided input values that will chec( each of the possi'le outputs. 24 8rite a /ortran program to prompt for and read the &ear that a person was 'orn. The &ear must 'e 'etween 1000 and 2000. -f an invalid entr& is read, the program should displa& the message, L$orr&, that is not a valid &ear.L and re6prompt. -f the correct value is not provided after attempts, the program should displa& the message L$orr&, please &our having pro'lems.L and terminate. <nce a valid &ear is read, the should displa& the &ear and a message Lis a leap &earL or Lis not a leap &earL. -nclude program statements, appropriate declarations, prompts, read statements, calculations, and write statements. Test the program on a series of input values. 4 T&pe in the grades program, compile, and e*ecute the program. Test the program on a series of input values that will chec( each grade. !4 Iodif& the grades program to handle the following grade assignmentP + [0! +6 0 600 =O B06BA = BD6B! =6 B 6B0 :O A06AA : AD6A! :6 A 6A0 ; D06D0 / Z10
:ompile, and e*ecute the program. Test the program on a series of input values that will chec( each grade.
1!
:hapter B M $election $tatements 14 8rite a /ortran program to prompt and read &ahrenheit as an integer, convert to celsius, and displa& the result as a real. The formula to convert &ahrenheit to celsius is celsius = fahrenheit !2 (' &)
The &ahrenheit value must 'e 'etween 610.0 and 110.0 3inclusive4. -f the &ahrenheit value is out of range, the program should displa& an error message, LTemperature out of rangeL, and re6 prompt. -f there are invalid temperatures, the program should displa& L$orr& &our having pro'lems.L and terminate. The calculations must 'e performed as real. -nclude program statements, appropriate declarations, prompts, read statements, calculations, and write statements. Test the program on a series of input values. D4 8rite a /ortran to program that reads an item cost 3real num'ers4 and amount tendered 3real num'er4 and compute the correct change. The correct change should 'e returned as the num'er of twenties, tens, fives, ones, @uarters, dimes, nic(els, and pennies. The main program should ensure that the amount paid e*ceeds the item cost and, if not, displa& an appropriate error message. Test the program on a series of input values. A4 8rite a /ortran to program that reads a num'er from the user that represents a television channel and then uses a :+$E construct to determine the call letters for that station. Channe* 1 B 10 1 Ca** /etters GF=: GFFU G9+$ G9FJ GTNF 1==i*iation N=: /<J :=$ .u'lic +=:
The program should displa& an appropriate message if an invalid or unassigned channel is entered. Test the program on a series of input values that will show each station.
11
1D
Loo"ing
8hen a series of /ortran statements need to 'e repeated, it is referred to as a loop or do)loop. + /ortran do)loop is a special control statement that allows a /ortran statement or set of statements to 'e e*ecuted multiple times. This repetition can 'e 'ased on a set num'er of times, referred to as counter controlled, or 'ased on a logical condition, referred to as conditionall& controlled. Each of these looping methods is e*plained in the following sections.
9.1 Counter Controlled Loo"ing

+ counter controlled loop is repeats a series of one or more /ortran statements a set num'er of times. The general format of the counting loop is#
do count_variable = start, stop, step <fortran statement(s)> end do
where the count varia'le must 'e an integer varia'le, start, stop, and step are integer varia'les or integer e*pressions. The step value is optional. -f it is omitted, the default value is 1. -f used, the step value cannot 'e ?ero. The Zfortran statement3s4[ is a se@uence of statements and is referred to as the bod% of the do6loop. "ou can use an& e*ecuta'le statement within a do6loop, including -/6THEN6 E9$E6EN; -/ and even another do6loop. =efore the do6loop starts, the values of start, stop, and step are computed e*actl& once. Iore precisel&, during the course of e*ecuting the do6loop, these values will not 'e re6computed. The count varia'le receives the value of start varia'le or e*pression. -f the value of control6var is less than or e@ual to the value of stop6value, the Zfortran statement3s4[ part is e*ecuted. Then, the value of step 31 if omitted4 is added to the value of control6var. +t the end, the loop goes 'ac( to the top and compares the values of control6var and stop6value. -f the value of control6var is greater than the value of final6value, the do)loop completes and the statement following end do is e*ecuted. /or e*ample, with the declarations,
integer :: counter, init=1, final=10, sum=0
the following do6loop,

do counter = init, final sum = sum + counter end do write (*,*) "Sum is: ", sum
will add the num'ers 'etween 1 and 10 which will result in 11. $ince the step was not specified, it is defaulted 1. 1A
:hapter 0 K 9ooping +nother e*ample, with the declarations,

integer :: counter, init=1, final=10, step=2
and the following do6loop,

do counter = init, final, step write (*,*) counter end do
will displa& the odd num'ers 'etween 1 and 10 31, , 1, A, 04. +nother e*ample would 'e to read some num'ers from the user and compute the sum and average of those num'ers. The e*ample as(s the user how man& num'ers, reads that man& num'ers, computes the sum, and the computes the average, and displa&s the results.
program average implicit none integer :: count, number, sum, input real :: average write(*,*) "Enter count of numbers to read" read(*,*) count sum = 0 do number = 1, count read(*,*) input sum = sum + input end do average = real(sum) / real(count) write *(*,*) "Average = ", average end program average
The use of the function real() converts the sum and count varia'les from integers to real values as re@uired for the average calculation. 8ithout this conversion, sum5count division would 'e interpreted as dividing an integer '& an integer, &ielding an integer result. + final e*ample of a counter controlled loop is to compute the factorial of a positive integer. The factorial of an integer n, written as n\, is defined to 'e the product of 1, 2, , ..., n61, and n. Iore precisel&, n\ U 1 Y 2 Y Y ... Y n.
integer :: factorial, n, i factorial = 1 do i = 1, n factorial = factorial * i end do
the a'ove do6loop iterates n times. The first iteration multiplies factorial with 1, the second iteration multiplies factorial with 2, the third time with , ..., the ith time with i and so on. Thus, the values that 1B
:hapter 0 M 9ooping are multiplied with the initial value of factorial are 1, 2, , ..., n. +t the end of the do6loop, the value of factorial is 1 Y 2 Y Y ... Y n which is nJ.
9. ,:IT and C;CL, 'tatements

The e*it and c&cle statements are used to modif& the e*ecution of a do6loop. The exit statement is used to e*it a loop. The e*it can 'e used alone, 'ut it is t&picall& used with a conditional statement to allow e*iting a loop 'ased on a specific condition. The exit statement can 'e used in a counter controlled loop or a conditionall& controlled loop. /or e*ample, given the following declarations,
integer :: i
the following loop,

do i = 1, 10 if (i == 5) exit write(*,*) i end do
will displa& the num'ers from 1 to ! s(ipping the remaining iterations. $ince the varia'le i is chec(ed 'efore the write statement, the value is not displa&ed with i is 1 and the loop is e*ited without completing the remaining iterations. 8hile it is possi'le to have multiple exit statements, t&picall& one one is used. However, multiple e*it statements ma& 'e re@uired for more comple* pro'lems. The c%cle statement will s(ip the remaining portion of the do6loop and start 'ac( at the top. The c%cle statement can 'e used in a counter controlled loop or a conditionall& controlled loop. -f the c&cle statement is used within a counter controlled loop, the ne*t inde* counter is updated to the ne*t iteration, which could terminate the loop. /or e*ample, given the following declarations,
integer :: i
the following loop,

do i = 1, 10 if (i == 5) continue write(*,*) i end do
will displa& the num'ers from 1 to ! and D to 10.
9.! Counter Controlled ,xam"le

-n this e*ample we will write a /ortran program to find the difference 'etween the sum of the s@uares and the s@uare of the sum of the first N natural num'ers.
10
:hapter 0 K 9ooping
;.3.1
-n order to find the difference 'etween the sum of the s@uares and the s@uare of the sum of the first N natural num'ers, we will need to find 'oth the sum of the s@uares and the s@uare of the sum. /or e*ample, the sum of the s@uares of the first ten natural num'ers is, 12 2 2 102 = B1
The s@uare of the sum of the first ten natural num'ers is, 1 2 10 2 = 112 = 021
Hence the difference 'etween the sum of the s@uares of the first ten natural num'ers and the s@uare of the sum is 021 6 B1 U 2D!0. The program will displa& the N value, the sum of the s@uares, the s@uare of the sum, and the difference for each num'er from 2 to a given N value. The program should prompt for and read the N value. The program will displa& appropriate headers.
;.3.2
/or this pro'lem, first we will need to read the N value. Then, we will loop from 1 to the N value and find 'oth the sum of the s@uares and the s@uare of the sum.
! ! ! ! ! ! ! ! ! ! declare variables integer -> i, j, n, SumOfSqrs, SqrOfSums display initial header prompt for and read the n value loop from 1 to N compute sum of squares compute sums square the sums compute difference between sum of squares and square of sums display results
;.3.3
De6elop the Program
=ased on the algorithm, the 'elow program could 'e developed.

program difference ! declare variables implicit none integer :: i, n, SumOfSqrs=0, SqrOfSums=0, difference
D0
:hapter 0 M 9ooping
! display initial header write(*,*) "Example Program" write(*,*) " Difference between sum of squares " write(*,*) " and square of sums" write(*,*) ! prompt for and read the n value write(*,*) "Enter N value: " read(*,*) n ! loop from 1 to N do i = 1, n ! compute sum of squares SumOfSqrs = SumOfSqrs + i**2 ! compute square of sums SqrOfSums = SqrOfSums + i end do ! square the sums SqrOfSums = SqrOfSums**2 ! compute difference between sum of squares and square of sums difference = SqrOfSums - SumOfSqrs ! display results write(*,*) "Difference: ", difference end program difference
The spacing and indentation is not re@uired, 'ut helps to ma(e the program more easil& reada'le.
;.3.4
/or this pro'lem, the testing would 'e to ensure that the results match the e*pected value. $ome e*pected results can 'e determined with a calculator or a spreadsheet. -f the program does not provided the correct result, one or 'oth of the intermediate results, 'um*f'!rs or '!r*f'ums, ma& 'e incorrect. These values can 'e displa&ed with a temporar& write statement to determine which might not 'e correct. -f the pro'lem is still not found, the intermediate values calculated during the loop can also 'e displa&ed with a write statement. The output can 'e reviewed to determine what the program is doing 3and what ma& 'e wrong4.
9.$ Conditional Controlled Loo"ing

+ conditional controlled loop repeats a series of one or more /ortran statements 'ased on a condition. +s such, the loop ma& e*ecute a indeterminate num'er of times.
D1
:hapter 0 K 9ooping <ne form of the conditional loop is#

do while (logical expression) <fortran statement(s)> end do
-n this form, the logical e*pression is re6chec(ed at the top of the loop on each iteration. + more general format of the conditional loop is#
do <fortran statement(s)> end do
+s is, this loop will continue forever. .ro'a'l& not so good. + selection statement, such as an -/ statement, and an exit statement would 'e used to provide an means to terminate the looping. /or e*ample,
do <fortran statement(s)> if (logical expression) exit <fortran statement(s)> end do
8ould stop looping onl& when the logical e*pression evaluates to true. The e*it statement can used used in multiple times in different locations as needed. +n -/ statement, in an& form, can 'e used for either the e*it of c&cle statements. /or e*ample, a conditional loop could 'e used to re@uest input from the user and (eep re6prompting until the input is correct.
integer :: month do write (*,*) "Enter month (1-12): " read (*,*) month if (month >= 1 .and. month <= 12) exit write (*,*) "Error, month must be between 1 and 12." write (*,*) "Please re-enter." end do
This will (eep re6prompting an unlimited num'er of times until the correct input 3a num'er 'etween 1 and 124 is entered.
D2
:hapter 0 M 9ooping $ince a counter controlled ;< loop re@uires an integer loop counter, another use of conditional loops would 'e to simulate a real counter. /or e*ample, to displa& the values from 1.1 to !.1 stepping '& 0.21, the following conditional loop could 'e used.
real :: value = 1.5 do write (*,*) "Value = ", value value = value + 0.25 end do
The values and step can 'e adEusted as needed.
9.5 Conditionally Controlled Loo" ,xam"le

-n this e*ample we will write a /ortran program read a valid date from the user. The date will consist of three values one for each of the month, date, and &ear. This e*ample will use some of the previous e*ample fragments.
;.-.1
/or this limited e*ample, we will re@uest a date where the &ear is 'etween 10A0 and 2020. The month must 'e 'etween 1 and 12. The date will depend on the month since some months have 0 or 1 da&s. /e'ruar& has either 2B da&s or 20 da&s if it is a leap &ear. ;ue to the limited allowa'le range of the &ear, the determination of a leap &ear can 'e performed '& chec(ing if the &ear is evenl& divisi'le '& ! 3which implies a leap &ear4.
;.-.2
/or this pro'lem, we will need to read the three values 3month, date, and &ear4. Then, we will chec( the values to ensure that date is valid. Then, we will chec( the month first and then the &ear since it will 'e used to chec( the date. The months Januar&, Iarch, Ia&, Jul&, +ugust, <cto'er, and ;ecem'er have 1 da&s. The months +pril, June, $eptem'er, and Novem'er have 0 da&s. /e'ruar& has 2B da&s unless the &ears is evenl& divisi'le '& !, in which case /e'ruar& has 20 da&s.
! declare variables; integer -> month, date, year ! display initial header ! loop ! request month, date, and year ! read month, date, and year ! check month (1-12) ! check year (1970-2020) ! check date ! 1,3,5,7,8,10,12 31 days ! 4,6,9,11 30 days ! 2 if modulo of year/4 is 0 29 days
:hapter 0 K 9ooping
! 2 if modulo of year/4 is /= 0 28 days ! display results
;.-.3
De6elop the Program

program datecheck ! declare variables implicit none integer :: month, date, year, datemax ! display initial header write(*,*) "Date Verification Example" ! loop do
! request month, date, and year write(*,*) "Date Verification Example" ! read month, date, and year read (*,*) month, date, year ! check month (1-12) if ( month < 1 .or. month > 12 ) then write(*,*) "Error, invalid month" cycle end if ! check year (1970-2020) if ( year < 1970 .or. year > 2020 ) then write(*,*) "Error, invalid year" cycle end if ! check date ! 1,3,5,7,8,10,12 31 days ! 4,6,9,11 30 days ! 2 if modulo of year/4 is 0 29 days ! 2 if modulo of year/4 is /= 0 28 days select case (month) case (1,3,5,7,8,10,12) datemax = 31 case (2) if (mod(year,4)==0) then
D!
:hapter 0 M 9ooping
datemax = 29
else
datemax = 28 end if case (4,6,9,11) datemax = 30 end select if ( date < 1 .or. date > datemax ) then write (*,*) "Error, invalid date." cycle end if exit end do ! display results write(*,*) "Valid Date is:", month, date, year end program datecheck
;.-.4
/or this pro'lem, the testing would 'e to ensure that the results match the e*pected value. This will re@uire entering a series of different dates and verif&ing that the displa&ed output is correct for the given input data.
9.0 ,xercises
;.&.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat happen when an exit statement is e*ecutedN 24 How man& exit statements can 'e included in a loopN 4 8hat happen when an continue statement is e*ecutedN !4 How man& continue statements can 'e included in a loopN 14 -f there are multiple c%cle statements in a loop, which one will 'e e*ecutedN
D1
:hapter 0 K 9ooping D4 8hat is the output of the following /ortran statements. +ssume sum and i are declared as integers.
sum = 0 do i = 1, 5 sum = sum + i end do write(*,*) "The SUM is:", sum
A4 8hat is the output of the following /ortran statements. +ssume i and + are declared as integer.
write(*,*) "start" do i = 1, 3 do j = 1, 2 write(*,*) i, " * ", j, " = ", (i*j) end do end do write(*,*) "end"
B4 +re the following /ortran statements valid or invalidN -f valid, what will happenN
do i = 3, 2 write(*,*) i end do
04 +re the following /ortran statements valid or invalidN -f valid, what will happenN
do i = 3, 3 if ( i == 3 ) then write(*,*) i end do end if
104 8hat is the limit of statements that can 'e included in a loopN 114 8hen an -/ statements 3an& form4 is nested inside a loop, what must 'e done to ensure the statements are validN
;.&.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the difference program, compile, and e*ecute the program. Test the program on a series of different input values. 24 T&pe in the date chec( program, compile, and e*ecute the program. Test the program on a series of different input values.
DD
:hapter 0 M 9ooping 4 8rite a program to calculate the range that a 'all would travel when it is thrown with an initial velocit& v, and angle -. =ased on an initial velocit& provided '& the user, calculate the range ever& 1 degrees for angles 'etween 1 and B1 degrees. -f we assume negligi'le air friction and ignore the curvature of the earth, a 'all that is thrown into the air from an& point on the earths surface will follow a para'olic flight path.
Origin
$m(act
``
,ime
The range 3distance 'etween the initial origin and final impact4 is determined '& the formula# 2 v2 0 range = cos - sin g where v, is the initial velocit& of the 'all, ` is the angle of the throw, and g is the acceleration due to the earth7s gravit&. The value for gravit& should 'e defined as a constant and set to 60.B1 meters per second.
*ote, the intrinsic trigonometric functions wor( in radians, so the angle in degrees will need to 'e converted to radians for the calculations. To convert degrees to radians# radians = degrees
( 1.0 )
Test the program on a series of different input values.
DA
:hapter 0 K 9ooping
DB
1<
Formatted In"ut8&ut"ut
/ortran uses a /<)I+T statement to allow control on how data is displa&ed or read. This is useful when ver& specific input or output is re@uired. /or e*ample, displa&ing mone& figures t&picall& re@uire e*actl& two decimal places. There are format specifiers for each data t&peP integer, real, character, logical, and comple*.
1<.1
Format
The format specifiers, separated '& commands, are contained in a pair of parenthesis. There are multiple possi'le wa&s to define a format. However, we will focus on the easiest, most direct method. The format specifier will replace the second ,Y2 in the read or write statements. /or e*ample#
read (*,'(<format specifiers>)') <variables> write (*,'(<format specifiers>)') <variables/expressions>
The following sections e*plain the options for the format specifiers.
1<.
Format '"ecifiers
The format specifiers tell the s&stem e*actl& how the input or output should 'e handled. Each value 'eing read or written re@uires some amount of space. /or e*ample, an integer of four digits re@uires at least four spaces or positions to print. Therefore, the num'er of positions to 'e used is a (e& part of the specifier. The following convention of s&m'ols# w. m. d. nQ r. the num'er of positions to 'e used the minimum num'er of positions to 'e used the num'er of digits to the right of the decimal point the num'er or count repeat count
The following is a summar& of the most commonl& used format specifiers# Description -ntegers )eal 9ogicals :haracters Hori?ontal .ositioning 3space4 #peci=ier rIw or rIw.m r%w.d r/w r1 or r1w nK
D0
:hapter 10 K /ormatted -nput5<utput Hori?ontal .ositioning 3ta'4 Fertical $pacing 4n 0
-n addition, each specifier or group of specifiers can 'e repeated '& preceding it with a repeat count. /ormat specifiers for comple* num'ers will 'e addressed in later chapters.
1<.!
Integer Format '"ecifier
The integer format specifier rIw or rIw.m is used tell the s&stem e*actl& how man& positions should 'e used to either read or write an integer varia'le. The w is the width or how man& total places are used. -f the num'er is negative, the sign uses a place. The m is optional and can 'e used to set a minimum num'er of digits to displa&, which will displa& leading ?ero7s if needed in order to displa& the minimum num'er of digits. The r is the num'er of times the format specifier should 'e repeated. + format of 73iD47 would loo( li(e# x / /or e*ample, given the declarations,
integer :: num1=42, num2=123, num3=4567
x w
x .
the following write statement can 'e used to displa& the value in varia'le num1 with no leading or trailing spaces.
write (*,'(i2)') num1
8hich will displa& ,422. Iultiple varia'les can 'e displa&ed. /or e*ample, to displa& the values in varia'les num1 and num2, with no leading or trailing spaces.
write (*,'(i2,i3)') num1, num2
8hich will displa& ,!212 2 with no spaces 'etween the two different values. However,
write (*,'(i2,i4)') num1, num2
will displa& ,42 1232 with one space 'etween the values. /urther,
write (*,'(3(i5))') num1, num2, num3
will displa& ,
42
123 45672 where each varia'le uses 1 spaces.
A0
:hapter 10 M /ormatted -nput5<utput
1<.$
+eal Format '"ecifier
The real format specifier r0w.d is used tell the s&stem e*actl& how man& positions should 'e used to either read or write an real varia'le. The w is the width or how man& total places are used, including the decimal point. -f the num'er is negative, the sign uses a place. The d is how digits are displa&ed after the decimal point, which does not count the decimal point. The r is the num'er of times the format specifier should 'e repeated. + format of 73fD.247 would loo( li(e# x / /or e*ample, given the declarations,
real :: var1=4.5, var2=12.0, var3=2145.578
x w
x .
/d.
the following write statement can 'e used to displa& the value in varia'le var1 with no leading or trailing spaces.
write (*,'(f3.1)') var1
8hich will displa& ,4.52 with no leading spaces. Iultiple varia'les can 'e displa&ed. /or e*ample, to displa& the values in varia'les var1 and var2.
write (*,'(f5.2,f8.3)') var1, var2
8hich will displa& , 4.50 as follows#
12.0002. +nother e*ample with three varia'les, var1, var2, and var3, is
write (*,'3(f10.4))') var1, var2, var3
8hich will displa& , 4.5000 12.0000 2145.57802 where each varia'le uses 10 spaces with each having e*actl& ! digits after the decimal point. +lthough we ma& print a num'er using as man& positions as &ou want, this is onl& for input5output formatting. The num'er of positions or si?e is not the precision 3i+e+, the num'er of significant digits4 of that num'er. The default precision of real num'ers is a'out seven significant digits. This is the precision of real num'ers. However, we can print a real num'er using 10 positions in which 21 positions are for the fractional part. This is onl& a wa& of descri'ing the appearance and does not change the precision of real num'ers.
1<.5
Logical Format '"ecifier
The logical format specifier r#w is used tell the s&stem e*actl& how man& positions should 'e used to either read or write an logical varia'le. The w is the width or how man& total places are used. The r is the num'er of times the format specifier should 'e repeated. $ince a logical varia'le can onl& 'e set to the logical constants .true. or .false. the width will specif& how man& of the characters logical constants will 'e read or displa&ed. A1
:hapter 10 K /ormatted -nput5<utput /or e*ample, given the declarations,

logical :: dooropen=.true., windowopen=.false.
the following write statement can 'e used to displa& the value in the logical varia'les dooropen and windowopen with no leading or trailing spaces.
write (*,'(l1,1x,l1)') dooropen, windowopen
8hich will displa& ,T F2. *ote, the *1 format is lower6case 9 and num'er 1. The si?e or width can 'e adEusted as needed. /or e*ample, the following write statement,
write (*,'(l4,2x,l5)') dooropen, windowopen
will displa& ,True
False2 3with two spaces4.
1<.0
Character Format '"ecifier
The real format specifier r&w is used tell the s&stem e*actl& how man& positions should 'e used to either read or write a character varia'le. The w is the width or how man& total places are used. -f the width is not specified, the e*isting length of the string is used. The r is the num'er of times the format specifier should 'e repeated. + format of 73aD47 would loo( li(e# c / /or e*ample, given the declarations,
character(len=11) :: msg = "Hello World"
c w
c .
the following write statement can 'e used to displa& the string in varia'le msg with no leading or trailing spaces.
write (*,'(a11)') msg
8hich will displa& ,Hello World2. The count is not re@uired when using the character format specifier. /or e*ample, the statement,
write (*,'(a)') msg
will displa& the same ,Hello World2 string. Iultiple varia'les or strings can 'e displa&ed. +lso, the count can 'e used to displa& a portion of the string. /or e*ample, to displa& the string in varia'le msg and the string ,Good '&e cruel world2.
write (*,'(a9,2x,a)') msg, "Good bye cruel world"
8hich will displa& ,Hello Wor Good bye cruel world2 to the screen. Note that of the 11 character string, onl& the first 0 characters are displa&ed.
A2
1<.5
%d)ance Clause
The advance clause instructs the computer whether or not to advance the cursor to the ne*t line. The possi'le values are ,&es2 and ,no2. -f the advance clause is not included, the default value is ,&es2. This clause can is useful when prompting for user input to allow the input to 'e entered on the same line as the prompt. /or e*ample, the period program from the previous chapter included the statements#
! prompt for and read the n value write(*,*) "Enter N value: " read(*,*) n
8hich, when e*ecuted, the input is entered on the line following the prompt.
c:\mydir> sums Example Program Difference between sum of squares and square of sums Enter count of numbers to read: 3 Difference: 2640
8hen the advance clause is included, with the setting of ,no2 as follows#
! prompt for and read the n value write(*,*, advance="no") "Enter N value: " read(*,*) n
The resulting e*ecution would 'e as follows#

c:\mydir> sums Example Program Difference between sum of squares and square of sums Enter count of numbers to read: 10 Difference: 2640
8hich allows the input to 'e entered on the same line as the prompt.
1<.9
,xam"le
This e*ample will read a date from the user 3month, date, and &ear, on the same line4, determine the da& of wee( 3for that month5date5&ear4. Then, the program will displa& the original input date 3numeric form4 and the formatted date. The original input date will 'e displa&ed include leading 07s 3i.e., 01501520104.
:hapter 10 K /ormatted -nput5<utput
1<.7.1
/or this pro'lem, we will read the three num'ers for the date from the user. The verification of the date information is left as an e*ercise. To calculate the da& on which a particular date falls, the following algorithm ma& 'e used 3the divisions are integer divisions4#
a = (14 - month) / 12 y = year - a m = month + 12*a - 2 daynum = [ date + y + y/4 - y/100 + y/400 + (31*m/12) ] mod 7
The value of daynum is 0 for a $unda&, 1 for a Ionda&, 2 for a Tuesda&, etc.
1<.7.2
/or this pro'lem, first we will need to read the date. The verification of the date entered and error chec(ing is left as an e*ercise. Then, the original input date can 'e displa&ed, in numeric form, formatted appropriatel&. /or a date, this would mean two digits for the month, a ,52, two digits for the date, a ,52, and four digits for the &ear. 8hen the date is onl& one digit, for e*ample 1, it is customar& to displa& a ,012 so the program will ensure this occurs.
! ! ! ! ! ! declare variables integer -> month, date, year display initial header prompt for month, date, and year read month, date, and year display formatted numeric month/date/year
Then the program can calculate the da& of the wee( 3'ased on the formula4 and convert the resulting num'er 306D4 into a date string and displa& the result.
! ! ! ! calculate day of week convert day of week (0-6) to string convert month (1-12) to string display formatted string for day, month, and year
1<.7.3
De6elop the Program

program dateformatter ! declare variables implicit none integer :: month, date, year integer :: a, m, y, d, character(9) :: amonth, day_of_week
A!
! ---------! display initial header write(*,*) "Date Formatting Example" ! prompt for month, date, and year write(*,*,advance="no") "Enter date (month, date, year):" ! read month, date, and year read (*,*) month, date, year ! ---------! display formatted numeric month/date/year write(*,*) "----------------------------------------" write(*,*) "Input Date: " write(*,'(5x, i2.2, a, i2.2, a, i4)', imonth, "/", & idate, "/", iyear ! ---------! calculate day of week a y m d = = = = (14 - imonth) / 12 iyear - a imonth + 12 * a - 2 mod ( (idate + y + y/4 - y/100 + y/400 + (31*m/12)), 7)
! ---------! convert day-of-week integer to day-of-week string select case (d) case (0) day_of_week case (1) day_of_week case (2) day_of_week case (3) day_of_week case (4) day_of_week case (5) day_of_week case (6) day_of_week end select
= "Sunday = "Monday = "Tuesday
" " "
= "Wednesday" = "Thursday " = "Friday "
= "Saturday "
A1
:hapter 10 K /ormatted -nput5<utput

! ---------! convert month (1-12) to string select case (month) case (1) amonth = "January case (2) amonth = "February case (3) amonth = "March case (4) amonth = "April case (5) amonth = "May case (6) amonth case (7) amonth case (8) amonth case (9) amonth case (10) amonth case (11) amonth case (12) amonth end select = "June = "July = "August
" " " " " " " "
= "September" = "October "
= "November " = "December "
! ---------! display formatted string for day, month, and year write(*,'(/a)') "Formatted Date:" write(*,'(5x, a, a, a, 1x, i2.0, a, i4/)') trim(day_of_week), ", ", trim(smonth), & idate, ", ", iyear end program dateformatter &
The spacing and indentation is not re@uired, 'ut helps to ma(e the program more easil& reada'le. The trim() intrinsic function removes an& trailing spaces from the input string. +dditional information regarding handling character data t&pes in provided in the following section.
1<.7.4
/or this pro'lem, the testing would 'e to ensure that the output formatting is correct. $ince there is no error chec(ing on the input, onl& correct dates should 'e entered. Test the program on a series of AD
:hapter 10 M /ormatted -nput5<utput different input values and verif& that the output is correct for those input values.
1<.9
,xercises
1<.;.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat is the format specifier for each of the following# a4 integer values '4 real values c4 logical values d4 hori?ontal spacing 3i.e., spaces4 e4 a newline f4 characters5strings 24 ;escri'e the output of the following code fragment 31 pts each4# *ote, show 'lan(s with an R 3underscore4 character.
write (*,'(a5)') "Hello World" write (*,'(a)') "Hello World"
4 ;escri'e the output of the following code fragment 3 pts4# Note, show 'lan(s with an R 3underscore4 character.
integer :: number = 5 write (*,'(i5.3)') number
!4 8hat is the write statement and format specifier to output the integer varia'le num1 which contains an value 'etween 0 and 000 3right Eustified, no leading ?ero7s, no additional spaces4. 14 8hat is the write statement and format specifier to output the real value of pi which has 'een initiali?ed to .1!110 3right Eustified, no additional spaces4N D4 8hat is the single write statement and format specifier to output L.rogrammingL and L-s /un\L on two different linesN A4 8hat is the single write statement and format specifier to output LEnter Num'er#L and leave the cursor on the current lineN
1<.;.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the date formatting program e*ample, compile, and e*ecute the program. Test the program on a series of different input values and verif& that the output is correct for those input values.
AA
:hapter 10 K /ormatted -nput5<utput 24 Update the date formatting program to perform complete error chec(ing on the date entered. That is, the program should chec( for appropriate values for month 3'etween 1 and 124, chec( for appropriate values for date 3'etween 1 and 14, including chec(ing for a valid date for the specific month, and ensure that the value for &ear is 'etween 10A0 and 000 3inclusive4. /or e*ample, +pril 1 is not a valid date. +dditionall&, the program should chec( for a leap &ear to see if /e'ruar& has 2B or 20 da&s for that &ear. Test the program on a series of different input values and verif& that the output is correct for those input values. 4 8rite a /ortran program that displa&s an amorti?ation schedule. The program should read the loan amount, annual interest rate, and the loan term in months 3from a single line4. The formula for calculating the monthl& pa&ment is# payment = amount irate
( 1 + irate ) term ( ( 1 + irate ) term 1)
*ote, the irate in the formula must 'e converted to a monthl& rate 3divided '& 124 and then divided '& 100 3to convert from percentage4. ;uring the time period 3term4, some of each monthl& pa&ment will 'e used to pa& the interest and some will 'e used to reduce the outstanding 'alance. The monthl& interest amount can 'e calculated '& monthl& interest rate times outstanding 'alance. The amounts must 'e lined up with onl& two digits for cents. The pa&ment num'er must three digits 3including leading ?ero7s if necessar&4. Test the program on a series of different input values and verif& that the output is correct for those input values. !4 8rite a /ortran program that calculates and displa&s compounded interest. The program should read the initial principal amount, interest rate percentage, and the term 3num'er of &ears4. The program should displa& a summar& of the input and the &earl& compounded interest. )efer to the e*ample output for formatting. The formula for compounding interest is# value = principal ( 1 + interest ) year *ote, the interest rate percentage read form the user must 'e converted to a num'er 3i.e., divided '& 1004. The output must 'e formatted in a manner similar to the e*ample output. This includes ensuring that the dollar amounts are displa&ed with the appropriate two decimal points. Test the program on a series of different input values and verif& that the output is correct for those input values.
AB
11
Characters and 'trings
/ortran was originall& developed for scientific and engineering application re@uiring significant mathematical calculations. However, the /ortran 01 language includes e*tensive character and string handling capa'ilities.
11.1
Character and 'tring Constants
+ character is a single character or s&m'ol, t&picall& enclosed in @uotes. /or e*ample, letters 3,+262W2 and ,a2 6 ,?24, punctuation 3,\2, ,,2, ,N2, etc.4 , s&m'ols, 3,S2, ,a2, ,[2, etc.4, and digits ,12, ,22 are characters. $ome e*amples include#
"X" "z" "5"
:haracter and string constants are case sensitive. $o, character ,J2 3upper6case4 is not the same as ,*2 3lower6case4. 8hen a digit is enclosed in @uotes, it is treated as a character and conse@uentl& arithmetic operations 3addition, su'traction, etc.4 are not allowed. + string is a series of characters. + string consists of an ar'itrar& se@uence of characters also enclosed in @uotes. $ome e*amples include#
"Hello World." "456" "1 2 3" "456?" "Good bye cruel world!!" "Have a nice day?"
$ince digits enclosed in @uotes are not numeric values, the strings ,1 2 2 and ,!1DN2 are allowed. + pro'lem arises if &ou want to have a @uote in the string itself. + dou'le @uote will 'e interpreted as a single within a string. The two @uotes must 'e together 3no spaces 'etween4. /or e*ample, the string#
"He said ""wow"" when he heard"
8ould 'e displa&ed as

"He said "wow" when he heard"
The dou'le6@uote is sometimes referred to as an escape character. $trings and characters must 'e associated with the character data t&pe.
A0
:hapter 11 K :haracters and $trings
11.
Character 3ariable #eclaration
+ character varia'le is a varia'le that can contain a set of 1 or more characters. :haracter varia'les must have a defined length. +ll declarations are placed in the 'eginning of the program 3after the program statement4. ;eclaring character varia'les formall& defines the t&pe and sets aside memor&. This is performed with a t&pe declaration statement in the form of#
<type> :: <list of variable names>
/or character varia'les, the t&pe is ,character2. /or e*ample, to define an character varia'le to hold the da& of wee( 3i.e., ,8ednesda&24, the following declaration,
character(len=9) :: dayofweek
8ould define the varia'le, dayofwee1, with a ma*imum length of 0 possi'le characters. +dditional e*amples include#
character(len=3) :: symbol1, symbol2 character :: symbol3 character(1) :: symbol5, symbol5 character(30) :: symbol6, symbol7
The declarations can 'e entered in an& order, however the& must 'e at the 'eginning of the program. The ,lenU2 is optional and can 'e omitted. 8hen the length is omitted entirel&, the default length is set to 1. This, ,character2, ,character3lenU14, and ,character3142 are all the same. 8hen multiple varia'les are included in a single declaration, the& must all 'e the same length. -f different lengths are re@uired, separate declaration lines are re@uired.
11.!
Character 3ariable Initiali(ation
-t is possi'le to declare a character varia'le and to set it is initial value at the same time. This initiali?ation is not re@uired, 'ut can sometime 'e convenient. /or e*ample, to define an character varia'le, dayofwee1, and set it to a da& of wee(#
character(len=9) :: todaysdate="Wednesday"

character(9) :: thismonth="June", lastmonth, nextmonth="July" character :: ltr1="A", ltr2="b"
$paces or no spaces 'etween the varia'les, e@ual signs, semicolons, and commas are allowed. Faria'les initiali?ed at declaration can 'e changed during program e*ecution as needed.
11.$
Character Constants
-t is possi'le to declare a character varia'le, set it is initial value, and ensure that the value can not 'e changed. /or e*ample, to define an character constant, lang,
character(len=7), parameter :: lang="English"
B0
:hapter 11 M :haracters and $trings To save counting the characters, the ,Y2 can 'e used. /or e*ample,
character(len=*), parameter :: university="UNLV"
This instructs the /ortran compiler to count the characters and set the appropriate length.
11.5
Character %ssignment
+ssignment is term for setting a character varia'le e@ual to some value 3character or string4. +ssignment is performed with a e@ual 3U4 sign. /or e*ample, given the declaration,
character(9) :: thismonth
+ value can 'e assigned to the varia'le as follows,

thismonth = "September"
8hen character varia'les are assigned the& are filled from the left and automaticall& padded with 'lan(s if necessar&. /or e*ample, if the varia'le thismonth is reset
thismonth = "May"
The varia'le thismonth contains ,Ia&
2 3e.g., ,Ia&2 with an additional D 'lan(s4.
11.0
Character &"erators
The onl& character operator is ,552 3concatenation4 which simpl& concatenates two strings together. /or e*ample,
"University of" // "Nevada Las Vegas"
:haracters varia'les and literals ma& 'e used with concatenation. /or e*ample, given the following declaration,
character(len=6) :: str1="ABCDEF", str2="123456" character(len=12) :: str3
The following statements

str3 = str1 // str2
will set str3 to ,+=:;E/12 !1D2.
11.5
Character 'ubstrings
+ su'string is a su'set of a string. + su'string can 'e selected 'ased on the characters position or count within the start with the first character corresponding to 1 and the second character corresponding to 2 as so forth for as man& characters are in the entire string. The su'string is specified with a start and stop position in the form of 3start#stop4. The stop must 'e greater than or e@ual to the stop position.
B1
:hapter 11 K :haracters and $trings /or e*ample, given the following declaration,
character(len=6) :: str1="ABCDEF", str2="123456", str3
The following statements

str3 = str1(1:3) // str2(4:6)
will set str3 to ,+=:!1D2.
11.9
Character Com"arisons
The standard relational operators 3,UU2, ,[2, ,[U2, etc.4 have some limitations when character data is used. $imple comparisons, such as,
"A" < "D" "ABC" == "ABC"
will wor( as e*pected. That is, 'oth will evaluate to true. However, when comparing, the following characters,
"A" > "a" "100" < "20" "ABC" <= "ABCD"
each will evaluate to false. This is a result of the relational operations referring to the assigned values 3'ased on their location in the +$:-- ta'le located in +ppendi* +4. :omparisons 'etween digits, ,02 6 ,02, will wor( relative to each other. :omparisons 'etween upper6 case letters, ,+2 6 ,W2, will also wor( relative to each other. :omparisons 'etween lower6case letters, ,a2 6 ,?2, will also wor( relative to each other. $ince the lower case letters are after the upper case letters in the ta'le an upper6case letter will 'e greater than a lower6case letter. The digits are in the ta'le 'efore letters 3upper and lower6case4, so the& will evaluate as less than letters. This must 'e ta(en into account when dealing with character comparisons.
11.9
Intrinsic Character &"erations
There are a num'er of character oriented intrinsic operations. $ome of the 'asic character oriented functions include#
%unction +:H+)3-4 Description )eturns the character represented '& integer argument 'ased on the +$:-- ta'le 3+ppendi* +4. -nteger argument must 'e 'etween 1 and 12A. )eturns the integer value of the character argument : represented '& +$:-- ta'le 3+ppendi* +4. )eturns an integer value representing the length of string argument $T).
-+:H+)3:4 9EN3$T)4
B2
:hapter 11 M :haracters and $trings

9ENRT)-I3$T)4 T)-I3$T)4 )eturns an integer value representing the length of string argument $T) e*cluding an& trailing spaces. )eturns string 'ased on the string argument $T) with an& trailing spaces removed.
+ complete list of intrinsic functions can 'e found in +ppendi* ;.
11.1<
,xam"le
This e*ample will scan a string and convert all lower6case letter to upper6case.
11.1<.1
/or this pro'lem, the string will 'e read from the user with a ma*imum of B0 characters. +n& lower case letters encountered will 'e converted to upper6case. +ll other characters 3digits, s&m'ols, etc.4 will 'e left alone. To determine if a characters is lower6case, we can see if it is 'etween ,a2 and ,?2. The final string will 'e displa&ed 'ac( to the screen. =ased on the +$:-- ta'le in +ppendi* +, there is a specific, fi*ed difference 'etween each upper and lower6case letter. Thus, in order to convert a lower6 case character to upper6case, that difference can 'e su'tracted. However, in order to perform the su'traction, each character needs to 'e converted into an integer 3'ased on its value in the +$:-- ta'le4. The -+:H+)34 intrinsic function performs this conversion. +fter the conversion 3su'traction4, the integer must 'e converted 'ac( into its corresponding character, which can 'e accomplished with the +:H+)34 intrinsic function. These functions wor( on a single character5integer, so each character will need to 'e addressed individuall&.
11.1<.2
/or this pro'lem, first we will need to prompt for and read the input string. Then an& trailing 'lan(s will 'e removed and the final length can 'e determined. =ased on that length, each character will 'e accessed and converted if needed.
! ! ! ! ! ! ! ! ! ! ! declare variables integer -> string1, string2, I, strlen display initial header prompt for string read string trim any trailing blanks determine length of string loop access each character if check lower-case ("a" "z") -> convert to upper-case display final string
:hapter 11 K :haracters and $trings
11.1<.3
De6elop the Program

program caseconverter ! declare variables implicit none integer :: i, strlen character(80) :: string1 ! ---------! display initial header write(*,'(a,/)') "Case Conversion Example" ! ---------! prompt for string ! read string write(*,'(a)',advance="no") "Enter String (80 char max): " read (*,'(a)') string1 ! ---------! trim any trailing blanks ! determine length of string strlen = len(trim(string1)) ! loop do i = 1, strlen ! ! access each character if check lower-case -> convert to upper-case
if ( string1(i:i) >= "a" .and. string1(i:i) <= "z" ) then string1(i:i) = achar( iachar(string1(i:i)) - 32) end if end do ! ---------! display final string write(*,'(/,a)') "-------------------------------------" write(*,'(a,/,2x,a,/)') "Final String: ", string1 end program caseconverter
B!
:hapter 11 M :haracters and $trings
11.1<.4
/or this pro'lem, the testing would ensure that the output string is correct for the given input. /or e*ample, the following output,
c:\mydir> case Case Conversion Example Enter String (80 char max): Hello World!? ------------------------------------Final String: HELLO WORLD!?
Each lower6case letter was converted to upper6case while the upper6case, space, and punctuation were unchanged. The program should 'e e*ecuted with a series of test inputs to verif& the correct output.
11.11
,xercises
11.11.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat is the declaration for a character varia'le, msg, to contain the string ,Hello World!2N 24 Given the following relational e*pressions,
"D" > "c" "100" < "20" "Da" > "cA" "20" < "10" "d" > "C" "20" < "100" "ABBC" <= "ABCD"
state which will evaluate to true and which to false.
B1
:hapter 11 K :haracters and $trings 4 Given the following /ortran statements,

character(len=*) :: str1="abcdef", str2="ABCDEF" character(len=*) :: str3="123456", str4="78910" character(len=12) :: astr1, astr2, astr3, astr4 astr1 astr2 astr3 astr4 = = = = str1(1:3) str3(4:6) str3 // str4 str2(4:6) // str3(1:3) // str1(2:3)
provide the resulting strings 3astr1, astr2, astr3, and astr24. !4 How can the integer value 3'ased on the +$:-- ta'le4 of a character 'e o'tainedN 14 How can integer value 'e converted to a character 3'ased on the +$:-- ta'le4N
11.11.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the case conversion e*ample program e*ample, compile, and e*ecute the program. Test the program on a series of different input values and verif& that the output is correct for those input values. 24 Update the case conversion e*ample program to convert an& upper6case characters to lower6 case characters. Test the program on a series of different input values and verif& that the output is correct for those input values. 4 8rite a program to read a string and count the vowels 3,a2, ,e2, ,i2, ,o2, and ,u24. The program should provided a count for each vowel and a total count of vowels. The program should ensure that the vowels are counted for 'oth upper and lower6case. Test the program on a series of different input values and verif& that the output is correct for those input values. !4 8rite a program to read 1 strings 3_ B0 characters each4 and displa& the strings in alpha'etical order. Test the program with a variet& of different input strings, including digits, upper6case, and lower6case characters. Test the program on a series of different input values and verif& that the output is correct for those input values.
BD
File &"erations
/ile operations allow /ortran programs to read from files and5or write to files. The 'asic read and write statements for file operations are the same as previousl& used with some additional information or clauses.
1 .1
File &"en
+ file must 'e opened 'efore information can 'e written or read from a file. -n order to open a file, the operating s&stem needs some information a'out the file in order to correctl& identif& the file and esta'lish the access parameters 3i.e., read, write, etc.4. The open statement ,clauses2 is how is information is provided. The file open statement is as follows#
open (unit=<unit number>, file=<file name>, & status=<file status>, action=<file action>, & position=<file position>, iostat=<status variable>)
The following ta'le summari?es the various open statement clauses. C*ause unit E+p*anation Unit num'er for su'se@uent file operations 3i.e., read, write, etc.4. T&picall& an integer 'etween 10 and 00. Name of file to 'e opened. :an 'e @uoted or a character varia'le. $tatus of file. +llowa'le options ,old2, ,new2, or ,repalce2 ,old2 Q the file must alread& e*ist. ,new2 Q a new file will 'e created. ,replace2 Q a new file will 'e created, replacing an e*isting one if necessar&. +ction or open operation. +llowa'le options are ,read2, ,write2, or ,readwrite2. ,read2 Q read data from a file. ,write2 Q write data to a file. ,readwrite2 Q simultaneousl& read data from and write data to a file. .osition or place to start. +llowa'le options are ,rewind2 3'eginning4, ,append2 3end4. BA
=i*e status
action
position
:hapter 12 K /ile <perations iostat Name of varia'le for s&stem to place a status code indicating the status 3success or failure4 of the operation. -f the status varia'le is set to 0, the operation is successful. -f the status varia'le is set to [0, an error occurred and the operation was unsuccessful.
The unit num'er assigned should 'e 'etween 10 and 00.
1 .
File Write
The file must 'e opened for ,write2 or ,readwrite2 access 'efore an& information can 'e written to the file. The general form of the write statement is as follows#
write (unit=<unit number>, fmt=<format statement>, advance="no", iostat=<variable>) <variables/expressions> & &
The write is the same as the simple write, however the unit num'er must 'e the num'er assigned during the open operation. Normall&, the ne*t write will 'e on the ne*t line. The ,advanceU2no22 is optional. -f it is included, the ne*t write will 'e on the same line where the previous line stopped. /or e*ample to open a file named temp.t*t and place the string ,/ortran E*ample2 and the num'ers !2, and .1!110 on separate lines, the following declarations#
integer :: myanswer=42, myopenstatus, mywritestatus real, parameter :: pi=3.14159 character(15) :: mymessage="Fortran Example" character(8) :: myfilename="temp.txt"
and the following /ortran statements,

open (unit=10, file=myfilename, status="replace", action="write", position="rewind", iostat=myopenstatus) if (myopenstatus > 0) stop "Can not open file." write(10, '(a/, i5/, f7.5)', iostat=mywritestatus) mymessage, myanswer, pi & & &
would write the file information to the file.
1 .!
File +ead
The file must 'e opened for ,read2 or ,readwrite2 access 'efore an& information can 'e read from the file. The general form of the write statement is as follows#
read (unit=<unit number>, fmt=<format statement>, iostat=<variable>) <variables/expressions> &
BB
:hapter 12 M /ile <perations The read is the same as the simple read, however the unit num'er must 'e the num'er assigned during the open operation. -f the status varia'le is set to less than 0, that is an indication that the end of the file has 'een reached. /or e*ample, if the file numbers.dat e*ists and has two num'ers 3on separate lines4, the following declarations,
integer :: num1, num2, myopenstatus, myreadstatus character(11) :: myfilename="numbers.txt"
and the following /ortran statements,

open (unit=12, file=myfilename, status="old", action="read", position="rewind", iostat=myopenstatus) if (myopenstatus > 0) stop "Can not open file." read(12, '(i5)', iostat=myreadstatus) num1 read(12, '(i5)', iostat=myreadstatus) num2 & &
would read information from the file.
1 .$
+e*ind
+n open file can 'e reset 'ac( to the 'eginning. This might 'e useful if the file needs to 'e read twice. The rewind statement will reset the file read pointer and su'se@uent reads will start 'ac( at the 'eginning. The general form of a rewind statement is#
rewind(<unit number>)
8here the the unit num'er was assigned during the initial open. The file must 'e open for the rewind to wor( correctl&.
1 .5
2ac/s"ace
8hen reading from a file, each successive read will return the ne*t line from the file. The computer (eeps trac( of which lines have 'een read and will automaticall& return the ne*t line. -t is possi'le to read a line and then 'ac(space and re6read the line again with the 'ac(space statement. The general form of a 'ac(space statement is#
backspace(<unit number>)
8here the the unit num'er was assigned during the initial open. The file must 'e open for the 'ac(space to wor(. This is not used ver& often.
B0
:hapter 12 K /ile <perations
1 .0
Close File
close(<unit number>)
+n open file should 'e closed when it is no longer needed. The general form of a close statement is#
8here the the unit num'er was assigned during the initial open. /or the previous e*amples,
close(10) close(12)
would 'e used to close the opened files.
1 .5
,xam"le
-n this e*ample we will write a /ortran program to read an input file and write a line num'er and the original line to an output file.
12.2.1
/or this pro'lem, we will read get the file names from the user and open the files. Then we will read a line from the input file, and write the line num'er and line to the output file. 8hen done, we will close the file.
12.2.2
/or this pro'lem, first we will need to prompt for and read the file names from the user and ensure that the& open correctl&. -f the file can not 'e opened, an error message will 'e displa&ed and the file names will 'e re6read.
! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! declare variables integer -> i, rdopst, wropst character -> line display initial header loop prompt for input file name read input file name open input file (read access) if open unsuccessful, display error message otherwise, end loop loop prompt for output file name read output file name open output file (write access) if open unsuccessful, display error message otherwise, end loop
<nce the file is open, a line will 'e read from the input file, and the line num'er and the line will 'e written to the output file. /or this e*ample, we will assume that a line will have 1 2 or less characters. 00
:hapter 12 M /ile <perations This process will continue until there are no more lines in the input file.
! loop ! read line from input file ! if end of file, exit loop ! write line number and line to output file ! close files
12.2.3
De6elop the Program

program linenumbers ! declare variables implicit none integer :: i, rdopst, wropst, rdst character(30) :: rdfile, wrfile character(132) :: line ! display initial header write(*,*) "Line Number Example" ! ---------! prompt for input file name do write(*,'(a)', advance="no") "Input File Name: " ! read input file name read(*,*) rdfile ! open input file (read access) ! if open unsuccessful, display error message ! otherwise, end loop open(12, file=rdfile, status="old", action="read", position="rewind", iostat=rdopst ) if (rdopst==0) exit
& &
write(*,'(a/,a)') "Unable to open input file.", & "Please re-enter" end do ! ---------! prompt for output file name do write(*,'(a)', advance="no") "Output File Name: "
01
! read output file name read(*,*) wrfile ! open output file (read access) ! if open unsuccessful, display error message ! otherwise, end loop open(14, file=wrfile, status="replace", action="write", position="rewind", iostat=wropst ) if (wropst==0) exit & &
write(*,'(a/,a)') "Unable to open output file.", & "Please re-enter" end do ! ---------i = 1 do
! read line from input file read(12, '(a)', iostat=rdst) line ! if end of file, exit loop if (rdst >0) stop "read error" if (rdst <0) exit
! write line number and line to output file write(14, '(i10,2x,a)') i, line i = i + 1 end do ! close files close(12) close(14) end program linenumbers
12.2.4
/or this pro'lem, the testing would involve e*ecuting the program with various input files and verif&ing that the line num'ers are correctl& added.
1 .9
,xercises
=elow are some @ui? @uestions and proEect suggestions 'ased on this chapter. 02
:hapter 12 M /ile <perations
12.7.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat must occur 'efore a file can 'e read or writtenN 24 8hat is the range of the valid unit num'ers for a file openN 4 /or the following statements#
integer :: opnstat character(20) :: filename="file.txt" open (14, file=filename, status="old", action="read", & position="rewind", iostat=opnstat) if ( opnstat > 0 ) then write (*, *) "Error, can not open file." stop end if
a4 8hat is the name of the file 'eing openedN '4 8hat is the unit num'er that will 'e used for su'se@uent write operationsN c4 ;oes the error message get printed if the file does not e*ist 3&es5no4N d4 8hat does it mean when the status varia'le is [ 0N !4 +ssume the file answers.txt e*ists, has 'een successfull& opened using unit num'er 20, and contains the following data#
"line 1 data1=23 data2 =034 data3 =05123"
8hat is the read statement re@uired to get data1, data2, and data into the integer varia'les num1, num2, and num3 respectivel&.
12.7.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the line num'ers program, compile, and e*ecute the program. Test the program on a num'er of different input values.
24 -magine the movement of a small circle that rolls on the outside of a rigid circle. -magine now that the small circle has an arm, rigidl& attached, with a plotting pen fi*ed at some point. That is a epic&cloid, commonl& called a spirographA. 8rite a /ortran 01 program to generate the 3*,&4 coordinates for a spirograph drawing. /irst, the program should prompt for an output file name, read the file name, and open the file. -f the file can not 'e opened, the program should displa& an appropriate error message and re6 prompt. Ne*t, the program should prompt for a read radius 1 3fi*ed circle4, radius 2 3moving circle4, offset position 3rigid arm length4. The radius 1, radius 2, and offset position values must 'e 'etween 6100 and O100 3inclusive4. -f an& value is out of range, the program should re6 prompt. -f the user does not enter a valid file name or num'er of input values after three tries, the program should terminate with an appropriate error message. That is, three errors are accepta'le, 'ut if a fourth error is made, the program should terminate. The prompts and su'se@uent reads should 'e on the same line 3see e*ample4. Then, the program should generate 3*,&4 points 'ased on one the following formulas#
x =(( radius 1+ radius2) cos ( step )) + offsetposition cos ( radius1 + radius2) y =(( radius 1+ radius2) sin ( step )) +
1 2
( (
( )) step offsetposition sin ( radius + radius ) ( radius ) )

step radius 2
2
The step should start at 0.0 and stop at D0.0, stepping '& 0.1. +ll writes should use a formatted output 3not the 7Y74. Then the program should close the output file, inform the user the plotting is completed. Test the program on a num'er of different input values. 4 8rite a /ortran program that pla&s the :haos Game. To pla& the :haos Game, plot points +, =, : and an ar'itrar& initial point J1. Then, generate a random num'er 'etween 1 and representing +, =, or :. -f + comes up, plot the midpoint of the line Eoining J1 to +. -f = comes up, plot the midpoint of the line Eoining J1 to =P the case with : is similar. :all this new point J2. )oll the die again. .lot the midpoint of the line Eoining J2 to either +, = or : depending on the outcome of the die toss. :all this new point J . )epeat this process N times. Test the program on a num'er of different input values. Note, the correct output of this program is shown on the cover page.
A /or more information, refer to# http#55en.wi(ipedia.org5wi(i5$pirograph
0!
1!
'ingle #imension %rrays
+n arra& is a collection or set of data. + varia'le can hold a single value. +n arra& can hold multiple values. The t&pe 3i.e., integer, real, etc.4 of each item in the arra& must 'e the same. -n order to access specific elements an index or subscript is used. The inde* specifies which element or value in the arra&. +n arra& is consider a direct access structure since an& element can 'e accessed directl&, without accessing an& other elements. The most 'asic form of an arra& is a single dimension arra&. + single dimension arra& can 'e thought of as a single column in a spreadsheet. The column name, li(e &, is the arra& name and the row num'er is li(e the inde*. /or e*ample, a single dimension arra& might loo( li(e# inde* +rra& Name 1 2 value Zvalue[ Zvalue[ ... ... Zvalue[ n Zvalue[
The specific s&nta* re@uires an inde* or su'script to specif& which element of the arra& to access. =& default, the first element is at inde*U1, the ne*t at inde*U2, and so forth. This can 'e changed if needed.
1!.1
%rray #eclaration
+n arra& must 'e declared 'efore use. The t&pe of the arra& is defined followed '& the si?e or dimension. There are two wa&s to declare an arra&P static and d&namic.
13.1.1
tatic Declaration
+ static declaration means that the si?e or dimension of the arra& must 'e defined initiall& 3'efore the program is compiled4. The si?e definition can not 'e altered. The general form an arra& declaration is,
type, dimension(extent) :: name1, name2, , nameN
where t&pe is the data t&pe 3integer, real, etc.4 of the arra&. The dimension specifies the the e*tent or si?e, and name1, name2, b, nameN are names of one or more arra&s 'eing declared. 01
:hapter 1
K $ingle ;imension +rra&s
/or e*ample, to declare an arra& of 1000 integers,

integer, dimension(1000) :: nums1
will create an arra&, nums1, with space for 1000 integer values. -n this e*ample the e*tent is 1000 which means that the arra& inde*es will range form 1 to 1000. The e*tent can 'e changed '& specif&ing the e*tent as#
smaller-integer :: larger-integer
8hen onl& one num'er is specified, the smaller6integer is assumed to 'e 1. 8hen 'oth num'ers are specified, the arra& inde*7s will range 'etween the smaller6integer and the larger6integer. /or e*ample, a declaration of#
integer, dimension(-5:5) :: ranges
will create an arra&, ranges, with inde*es 'etween 61 and 1 3inclusive4. Using inde* values not within the specified range will result in an error.
13.1.2
tatic 4rray Declaration
$tatic arra& declarations are appropriate when the ma*imum si?e of the arra& is (nown ahead of time. <nce the arra& is declared, the si?e can not 'e e*tended. + static arra& is initiali?ed and the si?e of set during the declaration. /or e*ample, to declare an arra& named costs with ! elements and set the four elements to 10.0, 11.0, 20.0, and 21.0,
real, dimension(4) :: costs=(/10.0, 15.0, 20.0, 25.0/)
The num'ers, enclosed 'etween the ,52s are assigned in order. $o, costs314 is set to 10.0, costs324 is set to 11.0, costs3 4 is set to 20.0, and costs3!4 is set to 21.0. +dditionall&, after declaration, it is possi'le to initiali?e all elements of an arra& to a single value with an assignment statement. /or e*ample,
costs = 0
will set all four elements of the costs arra& to ?ero.
13.1.3
Dynamic 4rray Declaration
+ d&namic declaration means that the si?e or dimension of the arra& can 'e set when the program is e*ecuted. ;&namic arra& declarations are appropriate when the ma*imum si?e of the arra& is not (nown ahead of time and can 'e determined 'ased on information o'tained when the program is e*ecuting. However, once set, the si?e can not 'e altered. 8hen using a d&namic declaration, the arra& t&pe and name must 'e defined. This onl& specifies the name and t&pe of the arra&, 'ut does not reserve an& space for the arra&. ;uring the program e*ecution, the arra& must 'e allocated. The allocation will create the space for the arra&. <nl& after the arra& has 'een allocated can it 'e used.
0D
:hapter 1 /or e*ample, to declare an arra&,

integer, dimension(:), allocatable :: nums2
M $ingle ;imension +rra&s
reserving the name nums2, 'ut not reserving an& space for values.
13.1.3.1
Dynamic 4rray 4llocation
To allocate the space for the arra&, the allocate statement must 'e used. =efore an arra& can 'e allocated, it must 'e declared as allocata'le. The general form of the allocate statement is#
allocate(<array name>, stat=<status variable>)
The status varia'le must 'e an integer varia'le and will 'e used '& the s&stem to place a status code indicating the status 3success or failure4 of the operation. -f the status varia'le is set to 0, the allocation was successful. -f the status varia'le is set to [0, an error occurred and the allocation was not unsuccessful. /or e*ample, given the declarations,
integer, dimension(:), allocatable :: nums2 integer :: allst
the following allocate statement allocates space for 1000 num'ers in arra& nums2,
allocate(num2(1000), stat=allst)
The si?e, 1000 in this e*ample, can 'e a varia'le, 'ut it must 'e an integer. The varia'le allst will 'e set to 0 if the allocation is successful and [0 if the allocation failed.
1!.
%ccessing %rray ,lements
To access elements in an arra&, the arra& name and the an inde* must 'e specified. The inde* is must 'e an integer or integer e*pression and enclosed in parentheses. The general format is,
array-name(<integer expression>)
/or e*ample, given the declaration,

real, dimension(10) :: times
would declare an arra& with ten elements. To place a value 121. in the first arra& element,
times(1) = 121.3
+nd to place 0B.121 in the fifth element,

times(5) = 98.125
The inde* in these e*amples is a literal. However, the inde* can 'e an integer varia'le or integer e*pression.
0A
:hapter 1
/or e*ample, given the following declarations,

real, dimension(10) :: temps integer :: i=5, j
would declare an arra& with ten elements. To place a value 0B.D in the fifth arra& element,
temps(i) = 98.6
To access the fifth element, su'tract .0 and place the result in the si*th element,
temps(i+1) = temps(i) 3.0
To set all elements of the temps arra& to 0.0, a loop could 'e used as follows#
do i = 1, 10 temps(i) = 0.0 end do
+rra& elements can 'e accessed as man& times as needed.
1!.!
Im"lied #o=Loo"
+n implied do6loop is a special form of a loop that can 'e performed on one line. This can 'e useful for accessing elements in an arra&. /or e*ample, assuming i is declared as an integer, the following code,
do i = 1, 5 write(*,*) nums(i) end do
would displa& each element the 1 element arra& to the screen. The same thing can 'e accomplished with an implied do6loop as follows#
write(*,*) (nums(i), i=1,5)
=oth forms of the loop will displa& the same results. -f necessar&, a step can 'e used. -f the step is omitted, as in the e*ample, the step is defaulted to 1.
1!.$
Initiali(ing %rrays
+n arra& can 'e initiali?ed when it is declared. Each element in the arra& can 'e initiali?ed to a single value or each element to a different value. The following declaration,
real, dimension(10) :: numbers = 1.0
will initiali?e each of the 10 elements in the arra& num'ers to 1.0. To initiali?e each element to a different value, each value needs to 'e specified.
0B
:hapter 1 /or e*ample, the following declaration,
real, dimension(5) :: numbers = (/ 1.0, 2.0, 3.0, 4.0 5.0 /)
will initiali?e each of the 1 elements in the arra& num'ers to 1.0, 2.0, .0, !.0, and 1.0 respectivel&. The implied do6loop ma& also 'e used. /or e*ample, in the following declaration,
integer, dimension(5) :: numbers = (/ (i, i=1,5) /)
will initiali?e each of the 1 elements in the arra& num'ers to 1, 2, , !, and 1 respectivel&.
1!.5
,xam"le
-n this e*ample we will write a /ortran program to read a series of num'ers from a file and compute some statistical information including minimum, ma*imum, sum, average, and standard deviationB. The standard deviation is calculated as follows#
standard deviation =
( average list ( i ))2

i =1
+s such, the average must 'e calculated 'efore the standard deviation.
13.-.1
The program will displa& an initial header and get the file name. $pecificall&, we will need to prompt for the file name, read the file name, and verif& that the file is availa'le '& attempting to open the file. Then, the program will read the num'ers from the file and store them in an arra&. /or this pro'lem, there will 'e no more than 1000 num'ers in the file. +fter the num'ers are in the arra&, the minimum, ma*imum, and sum will 'e found. Ne*t, the average can 'e computed. /inall&, the standard deviation can 'e calculated in steps, the first of which is computing the inner loop. The num'ers should 'e displa&ed, ten per line, followed '& the results.
13.-.2
+fter the header is displa&ed, the program should prompt for the file name, read the file name, and verif& that the file is availa'le '& attempting to open the file. -f the file can not 'e opened, the program will displa& an error message and re6prompt. -f the user does not enter correct information after three tries, the program should terminate with an appropriate error message. That is, three errors are accepta'le, 'ut if a fourth error is made, the program will terminate.
! declare variables ! integer -> i, ncount, errs, opstat, rdstat ! real -> min, max, sum, stdsum ! real -> array for ! character -> filename(20) ! display initial header
B /or more information, refer to# http#55en.wi(ipedia.org5wi(i5$tandardRdeviation
00
:hapter 1

! loop ! prompt for file name ! read file name ! attempt to open file ! if file open successful, exit loop ! display error message ! count error ! if >3 errors, terminate program ! end loop
Then, the program will loop to read the num'ers from the file and store them in an arra&. The program will chec( for an& read errors 3status varia'le [ 04 and for the end of file 3status varia'le Z 04. -f a valid num'er is read, it will 'e counted and placed in the arra&.
! loop ! read from the file ! if error on read, terminate program ! if end of file, exit loop ! increment number counter ! place number in array ! end loop
Ne*t, another loop will 'e used to find the minimum, ma*imum, and sum of the num'ers. To find the the minimum and ma*imum values, we will assume that the first element in the arra& is the minimum and ma*imum. Then, the program will chec( each num'er in the arra&. -f the num'er from the arra& is less than the current minimum value, the current minimum value will 'e updated to the new value. $ame for the ma*imum, if the num'er from the arra& is more than the current ma*imum value, the current ma*imum value will 'e updated to the new value.
! initialize min, max, and sum ! loop ! check for new min ! check for new max ! update sum ! end loop
<nce the sum is availa'le, the average can 'e computed. /inall&, a loop will 'e used to calculate the summation for the standard deviation.
! ! ! ! ! ! calculate average initialize stdsum loop calculate average array item update stdsum end loop
<nce the summation is completed, the standard deviation can 'e computed and the final results displa&ed. +s per the e*ample specifications, the num'ers should 'e displa&ed 10 per line.
100
:hapter 1
<ne wa& to handle this is to displa& num'ers on the same line 3with the ad'ance,-no- clause4 and ever& 10th line displa& a new line.
! ! ! ! calculate standard deviation loop to display numbers, 10 per line display results end program
13.-.3
De6elop the Program

program standardDeviation ! declare variables implicit none integer :: i, ncount=0, errs=0, opstat, rdstat real :: num, min, max, sum, stdsum real, dimension(5000) :: numbers character(20) :: filename ! display initial header write (*,*) "Standard Deviation Program Example." ! loop do ! prompt for file name write (*,'(a)', advance="no") "Enter File Name:" ! read file name read (*,*) filename ! attempt to open file open(42, file=filename, status="old", action="read", position="rewind", iostat=opstat ) ! if file open successful, exit loop if (opstat==0) exit ! display error message write (*,'(a)') "Error, can not open file." write (*,'(a)') "Please re-enter." ! count error errs = errs + 1 & &
101
:hapter 1
! if >3 errors, terminate program if (errs > 3) then write (*,'(a)') "Sorry your having problems." write (*,'(a)') "Program terminated." stop end if ! end loop end do ! loop do
! read file read (42, *, iostat=rdstat) num ! if error on read, terminate program if (rdstat>0) stop "Error on read." ! if end of file, exit loop if (rdstat<0) exit ! increment number counter ncount = ncount + 1 ! place number in array numbers(ncount) = num
! end loop end do ! initialize min, max, and sum min = numbers(1) max = numbers(1) sum = 0.0 ! loop do i = 1, ncount ! check for new min and new max if (numbers(i) < min) min = numbers(i) if (numbers(i) > max) max = numbers(i) ! update sum sum = sum + numbers(i) ! end loop end do ! calculate average
102
:hapter 1
average = sum / real(ncount) ! initialize stdsum stdsum = 0.0 ! loop do i = 1, ncount
! calculate (average array item)^2 and update sum stdsum = stdsum + (average - numbers(i))**2 ! end loop end do ! calculate standard deviation std = sqrt ( stdsum / real(ncount) ) ! display results write (*,'(a)') "-------------------------------" write (*,'(a)') "Results:" do i = 1, ncount write(*,'(f8.2,2x)', advance="no") numbers(i) if (mod(i,10)==0) write(*,*) end do write write write write write (*,'(a, (*,'(a, (*,'(a, (*,'(a, (*,'(a, f8.2)') f8.2)') f8.2)') f8.2)') f8.2)') "Minimum = ", min "Maximum = ", max "Sum = ", sum "Average = ", average "Standard Deviation = ", std
end program standardDeviation
13.-.4
/or this pro'lem, the testing would involve e*ecuting the program using a file with a set of num'ers where the correct results are either (nown ahead of time or can 'e calculated '& hand in order to verif& that the results are accurate.
1!.0
%rrays of 'trings
+n arra& ma& also contain characters or strings. The declaration and and access of arra& elements is the same. However, the string si?e must 'e included in the declaration and can not 'e easil& changed once define.
10
:hapter 1
/or e*ample, to declare an arra& to hold 100 titles where each title is a ma*imum of !0 characters,
character(40), dimension(100) :: titles
$etting an element is the same. /or e*ample, to set the first element of the arra& to the title of this te*t,
titles(1) = "Introduction to Programming using Fortran 95"
:haracter arra&s ma& 'e staticall& or d&namicall& declared as noted in the previous sections.
1!.5
,xercises
13.2.1
Quiz Questions
=elow are some @ui? @uestions. 14 E*plain wh& an arra& is considered a direct access structure. 24 :an arra&s hold integer values 3&es5no4N 4 :an arra&s hold real values 3&es5no4N !4 8rite the declarations for the following# a4 +n integer constant, $-WE1, set to 100. '4 +n arra&, ivalues, with 10 real elements. c4 +n arra&, inums, with $-WE1 integer arguments. d4 +n arra&, counts, with 10 real elements whose su'script values range from 0 to 0. 14 Given the declarations and the following code#
integer, dimension(4) :: arr integer :: k arr(1) arr(2) arr(3) arr(4) k = 3 = = = = 10 15 20 25
a4 '4 c4 d4
8hat does arr(1) e@ualN 8hat does arr(1) + arr(2) e@ualN 8hat does arr(1+2) e@ualN 8hat does arr(k) e@ualN
10!
:hapter 1 D4 8hen can an arra& 'e allocated 3two options4N A4 Given the following statements#
integer, dimension(5) :: nums integer :: i=1 nums = 0 do if ( i == 5 ) exit if ( mod(i,2) == 0) then nums(i) = 99 else nums(i) = i end if i = i + 1 end do
a4 what values are in arra& after e*ecution '4 8hat is the (nums(i), i=1,5) referred to asN c4 8hat does write(*,'(1x,i2)') (nums(i), i=1,5) displa&. Note, use an unederscore 3,R24 for to show the spaces.
13.2.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the standard deviation program, compile, and e*ecute the program. Test the program on a series of different input values. 24 8rite a /ortran program to cu'e read a series of integer num'ers from a file and cu'e each num'er. The program should also calculate the real average of the original num'ers and the real average of the cu'ed num'ers. Test the program on a series of different input values. 4 8rite the program to generate a series of real values 'etween 1.0 and 100.0 and store the num'ers in an arra&. Then, the program should compute the norm of a vector 3single dimension arra&4. The formula for norm is as follows#
norm =
2 1
2 2 + a2 2 + a! + ... + an
)efer to +ppendi* : for more information regarding generating random num'ers. Test the program on a series of different input values.
101
:hapter 1
!4 8rite a /ortran program to read a series of num'ers from a file, store the num'ers in an arra&, and then sort the num'ers using the following selection sort algorithm#
for i = len downto 1 big = arr(1) index = 1 for j = 1 to i if arr(j) > big big = arr(j) index = j end_if end_for arr(index) = arr(i) arr(i) = big end_for
"ou will need to convert the a'ove pseudo6code algorithm into /ortran code. Test the program on a series of different input values.
10D
1$
6ultidimensional %rrays
+ more advanced arra& is a multidimensional arra&. + multidimensional arra& can 'e thought of as a multiple columns in a spreadsheet. The column name, li(e &, 3, %, etc. are the arra& columns and the num'er is li(e the row. /or e*ample, a two dimension arra& might loo( li(e# inde* +rra& Name 1 2 1 Zvalue[ Zvalue[ ... ... Zvalue[ n Zvalue[ 2 Zvalue[ Zvalue[ ... ... Zvalue[ Zvalue[
The specific s&nta* re@uires an inde* or su'script to specif& which element of the arra& to access. The inde*ing for a two dimension arra& is# inde* +rra& Name 1 2 1 arr31,14 arr32,14 arr3 ,14 ... ... n arr3n,14 2 arr31,24 arr32,24 arr3 ,24 ... ... arr3n,24
=& default, the first element is at inde*U1, the ne*t at inde*U2, and so forth. This default 3where the first num'er is at inde* 14 can 'e changed if needed.
1$.1
%rray #eclaration
Iultidimensional arra& declaration is ver& similar to single6dimension arra& declaration. +rra&s must 'e declared 'efore use. The t&pe of the arra& is defined followed '& the si?e or dimension, which in this case re@uires a si?e for each dimension. +s 'efore, there are two wa&s to declare an arra&# static and d&namic.
10A
:hapter 1! K Iultidimensional +rra&s
14.1.1
tatic Declaration
+ static declaration means that the si?e or dimension of the arra& must 'e defined initiall& 3'efore the program is compiled4. The si?e definition can not 'e altered. The general form of an arra& declaration is,
type, dimension(extent,extent) :: name1, name2, ... , nameN
where t%pe is the data t&pe 3integer, real, etc.4 of the arra&. The dimension specifies the si?e, and name1, name2, ... , nameN are names of one or more arra&s 'eing declared. /or e*ample, to declare a two6dimensional arra& 100 '& 100,
integer, dimension(100,100) :: nums1
will create an arra&, nums1, with space for a total of 10,000 integer values.
-n this e*ample the e*tent for each dimension is 100 which means that each of the two dimension7s inde*es will range form 1 to 100. Each or 'oth e*tent7s can 'e changed '& specif&ing the e*tents as#
(smaller-integer:larger-integer, smaller-integer:larger-integer)
8hen onl& one num'er is specified, the smaller6integer is assumed to 'e 1. 8hen 'oth num'ers, smaller and larger inde*, are specified the dimension of the arra& will range 'etween the smaller6 integer and the larger6integer. /or e*ample, a declaration of#
integer, dimension(0:9,0:9) :: ranges
will create an arra&, ranges, with 'oth inde*es 'etween 0 and 0 3inclusive4. Using inde* values not within the specified range will result in an error.
14.1.2
Dynamic Declaration
The same as single dimension, a d&namic declaration means that the dimension of the arra& can 'e set when the program is e*ecuted. <nce set, the dimensions can not 'e altered. 8hen using a d&namic declaration, the arra& t&pe and name must 'e defined, which specifies onl& the name and t&pe of the arra&, 'ut does not reserve an& space for the arra&. Then, during program e*ecution, the arra& can 'e allocated which will create the space for the arra&. <nl& after the arra& has 'een allocated can it 'e used. /or e*ample, to declare an arra&,
integer, dimension(:,:), allocatable :: nums2
reserving the name nums2, 'ut not reserving an& space for values.
14.1.3
Dynamic 4rray 4llocation
To allocate the space for the arra&, the allocate statement must 'e used. =efore an arra& can 'e allocated, it must 'e declared as allocata'le. The general form of the allocate statement is#
allocate(<array name>, <dimension>, stat=<status variable>)
The status varia'le must 'e an integer varia'le and will 'e used '& the s&stem to place a status code 10B
:hapter 1! M Iultidimensional +rra&s indicating the status 3success or failure4 of the operation. +s 'efore, if the status varia'le is set to 0, the allocation was successful. -f the status varia'le is set to [0, an error occurred and the allocation was not unsuccessful. /or e*ample, given the declarations,
integer, dimension(:,:), allocatable :: nums2 integer :: allstat
the following allocate statement allocates space for 10,000 num'ers in arra& nums2,
allocate(nums2(100,100), stat=allstat)
The si?e, 100 '& 100 in this e*ample, can 'e a parameter or varia'le, 'ut it must 'e an integer. The varia'le allstat will 'e set to 0 if the allocation is successful and [0 if the allocation failed.
1$.
%ccessing %rray ,lements
To access elements in an arra&, the arra& name and the an inde* must 'e specified. The inde* must include an integer or integer e*pression for each dimension enclosed in parentheses. The general format is,
array-name(<integer expression>, <integer expression>)
/or e*ample, given the declaration,

real, dimension(10,5) :: table1
would declare an arra&, table1, with a total of 10 elements. To place a value 121. in the first row and first column,
table1(1,1) = 121.3
+nd to place 0B.121 in the tenth row and fifth column,

table1(10,5) = 98.125
The inde* in these e*amples is a literal. However, the inde* can 'e an integer varia'le or integer e*pression. /or e*ample, given the following declarations,
real, dimension(10,10) :: tmptable integer :: i=2, j=3
would declare an arra&, tmptable, with ten elements. To place a value 0B.D in the second row, fourth column,
tmptable(i,j+1) = 98.6
To access the same element, su'tract .0 and place the result 'ac( into the same location,
tmptable(i,j+1) = tmptable(i,j+1) 3.0
100
:hapter 1! K Iultidimensional +rra&s To set all elements of the tmptable arra& to 0.0, a nest loop could 'e used as follows#
do i = 1, 10 do j = 1, 10 tmptable(i,j) = 0.0 end do end do
-n addition, the entire arra& can 'e set to 0 in the following statement,
tmptable = 0.0
+rra& elements can 'e accessed as man& times as needed.
1$.!
,xam"le
-n this e*ample we will write a /ortran program that will re@uest a count, generate count 3x,y4 random points, and perform a Ionte :arlo > estimation 'ased on those points. +ll x and y values are 'etween 0 and 1. The main routine will get the count and the use a su'routine to generate the random 3x,y4 points and a function, to perform the Ionte :arlo > estimation. /or this e*ample, the count should 'e 'etween 100 and 1,000,000.
14.3.1
=ased on the pro'lem definition, we will use a main routine that will get and chec( the count value. -f the count is not 'etween 100 and 1,000,000, the routine will re6prompt until the correct input is provided. <nce a valid count value is o'tained, then the main will allocate the arra& and call the two su'routines. The first su'routine will generate the random 3x,y4 points and store them in an arra&. The second su'routine will perform the Ionte :arlo > estimation. Ionte :arlo methods are a class of computational algorithms that rel& on repeated random sampling to compute their results. $uppose a s@uare is centered on the origin of a :artesian plane, and the s@uare has sides of length 2. -f we inscri'e a circle in the s@uare, it will have a diameter of length 2 and a radius of length 1. -f we plot points within the upper right @uadrant, the ratio 'etween the points that land within the inscri'ed circle and the total points will 'e an estimation of >. est = 4 inside circ*e ( samp*es ) tota* samp*es
+s more samples are ta(en, the estimated value of > should approach the actual value of >. The .&thagorean theorem can 'e used to determine the distance of the point from the origin. -f this distance 110
:hapter 1! M Iultidimensional +rra&s is less than the radius of the circle, then the point must 'e in the circle. Thus, if the s@uare root of 3x2Oy24 Z 1.0, the random point is within the circle. /inall&, the figure we are discussing, a s@uare centered on the origin with an inscri'ed circle is s&mmetric with respect to the @uadrants of its :artesian plane. This wor(s well with the default random num'er generations of values 'etween 0 and 1.
14.3.2
The main routine will displa& an initial header, get and chec( the count value, and allocate the arra&. The program will need to ensure that the arra& is correctl& allocated 'efore proceeding. Then program can generate the 3x,y4 points. =ased on the pro'lem definition, each point should 'e 'etween 0.0 and 1.0 which is provided '& default '& the /ortran random num'er generator. Ne*t, the program can perform the Ionte :arlo pi estimation. This will re@uire the alread& populated 3x,y4 points arra& and the count of points. Each point will 'e e*amined to determine the num'er of points that lie within the inscri'ed circle. The .&thagorean theorem allows us to determine the distance of the point from the origin 30.0,0.04. Thus, for each point, we will calculate the ( x2 + y2 ) and if the distance is less than the circle radius of 1.0, it will 'e counted as inside the circle. Then, the estimated value of > can 'e calculated 'ased on the formula# est = 4 inside circ*e ( samp*es ) tota* samp*es
8hen completed, the program will displa& the final results. The 'asic algorithm is as follows#
! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! declare variables display initial header prompt for and obtain count value loop prompt for count value read count value if count is correct, exit loop display error message end loop allocate two dimension array generate points loop count times generate x and y values place (x,y) values in array at appropriate index end loop set count of samples inside circle = 0 loop count times if [ sqrt (x(i)2 + y(i)2) < 1.0 ] increment count of samples inside circle end loop display results
/or convenience, the steps are written a program comments. 111
14.3.3
De6elop the Program

program piestimation ! declare variables implicit none integer :: count, alstat, i, incount real :: x, y, pi_est, pt real, allocatable, dimension(:,:) :: points ! display initial header write (*,'(/a/)') "Program Example PI estimation." ! prompt for and obtain count value do ! prompt for count value write (*,'(a)', advance="no") "Enter Count (100 - 1,000,000): " ! read count value read (*,*) count ! if count is correct, exit loop if ( count >= 100 and count <= 1000000 ) exit ! display error message write (*,'(a,a,/a)') "Error, count must be ", "between 100 and 1,000,000.", "Please re-enter." end do ! allocate two dimension array allocate (points(count,2), stat=alstat) if (alstat <> 0 ) then write (*,'(a,/a)') "Error, unable to allocate" " memory.", "Program terminated." stop end if ! generate_points call random_seed() ! loop count times do i = 1, cnt ! generate x and y values call random_number(x) & &
&
&
112
:hapter 1! M Iultidimensional +rra&s

call random_number(y) ! place (x,y) values in array pts(i,1) = x pts(i,2) = y end do ! perform monte carlo estimation ! set count of samples inside circle = 0 incount = 0 ! loop count times do i = 1, cnt ! if [ sqrt (x(i)2 + y(i)2) < 1.0 ] ! increment count of samples inside circle pt = pts(i,1)**2 + pts(i,2)**2 if (sqrt(pt) < 1.0) incount = incount + 1 end do pi_est = 4.0 * real(incount) / real(cnt) ! display results write (*,'(a, f8.2)') "Count of points: ", count write (*,'(a, f8.2)') "Estimated PI value: ", pi_est end program piestimation
14.3.4
/or this pro'lem, the testing would involve e*ecuting the program using a series of different count values and ensure that the > estimate is reasona'le and improves with higher count values.
11
1$.$
,xercises
14.4.1
Quiz Questions
=elow are some @ui? @uestions. 14 :an a multidimensional arra& simultaneousl& hold 'oth integer and real values 3&es5no4N 24 Iultiple choice# what is the order of the inde*esN a4 '4 c4 d4 e4 3row, column4 3column, row4 3row, row4 3column, column4 user6selecta'le
*ote, there is onl& one correct answer. 4 Given the following code#
real, dimension(5,3) :: mdarr integer :: i, j do i = 1, 5 do j = 1, 3 mdarr(i,j) = real(i+j) end do end do
a4 '4 c4 d4 e4
How man& values, total, can 'e stored in the mdarr arra&N $how the contents of ever& cell in the mdarr. 8hat does mdarr(2,1) containN 8hat does mdarr(1,3) containN 8hat does mdarr(4,3) containN
!4 How can an unsuccessful multidimensional d&namic allocation 'e detectedN
14.4.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the > estimation program compile, and e*ecute the program. Test the program on a series of different point count values. ;emonstrate that larger point values provide a 'etter estimation.
11!
:hapter 1! M Iultidimensional +rra&s 24 Update the > estimation program to ensure that a valid count values is o'tained within three tries. -f there are more than three errors, the program should displa& an error message and terminate. 4 Update the > estimation program to displa& the estimated > value 10 times. -n order to perform this, the count value can 'e divided '& 10 and the current estimated > value displa&ed. !4 8rite a program to staticall& declare a 100*100 two dimensional arra& of real values. The program should populate the arra& with random num'ers 'etween 0 3inclusive4 and 1 3e*clusive4. )efer to +ppendi* : for information regarding generating random num'ers. The program should scan the arra& to find and displa& the ma*imum value and the location of that value 3ie., the row and column where the value was found4. 14 Update the find ma*imum program 3from the previous @uestion4 to declare the arra& d&namicall& and allow the user to enter a the row and column dimension7s and ensure that each is 'etween 10 and 1000. <nce entered, the program should allocate the arra& and find and displa& the ma*imum and minimum values and their locations 3row and column4. D4 8rite a /ortran program to construct an odd6order Iagic $@uare0. The algorithm for constructing an N*N odd ordered Iagic $@uare is as follows#

/irst, place a 1 in the middle of the top row. +fter placing an integer, 1, move up one row and one column to the right to place the ne*t integer, 141, unless the following occurs#
-f a move ta(es &ou a'ove the top row in the +th column, move to the 'ottom of the +th column and place the integer there. -f a move ta(es &ou outside to the right of the s@uare in the ith row, place the integer in the ith row at the left side. -f a move ta(es &ou to an alread& filled s@uare or if &ou move out of the s@uare at the upper right hand corner, place 141 immediatel& 'elow 1.
Test the program and compare the results to the 8i(ipedia e*ample.
0 /or more information, refer to# http#55en.wi(ipedia.org5wi(i5IagicRs@uare
111
11D
15
'ub"rograms
Until now, all of the programs have essentiall& 'een a single, fairl& small programs. However, as we scale up into larger programs, this methodolog& will 'ecome more difficult. 8hen developing larger programs, it 'ecomes necessar& to 'rea( the larger program up into multiple, smaller more managea'le pieces. Then, during program development, it is possi'le to focus on each su'section or piece individuall& and then com'ine the results into a final complete program. +nd, for ver& large proEects, multiple people ma& wor( on different parts of the program simultaneousl&. $ome of the (e& advantages of developing a program using functions and5or su'routines include#

$tructured development of programs )euse of su'programs -solation of su'programs
/ortran su'programs are the mechanism to 'rea( a large program into multiple smaller parts. This allows for a more comprehensive program design.
15.1
'ub"rogram Ty"es
There are two t&pes of /ortran su'programs# &unctions and subroutines, each of which is e*plained in the following sections.
15.
Program Layout
The functions and su'routines can 'e defined as either internal or e*ternal. -nternal functions and su'routines are defined within the program statement 3i.e., 'efore the ,end program Zname[2 statement4. The 'asic la&out for 'oth internal and e*ternal su'programs is as follows#
program <name> <declarations> <program statements> contains <internal functions or subroutines> end program <name> <external functions or subroutines>
8here a com'ination of 'oth or either internal or e*ternal routines is allowed. 11A
:hapter 11 K $u'programs
1-.2.1
,nternal Routines
-nternal routines re@uire the (e&word ,contains2 to separate the from the program code. .rimaril&, internal routines will 'e used in this te*t for simplicit&. There is no limit to the num'er of internal routines. However, if too man& routines are included the file will 'ecome large and large files can 'e difficult to wor( with.
1-.2.2
"#ternal Routines
E*ternal functions are defined outside the program statement 3i.e., after the ,end program Zname[2 statement4 or in another file. /or larger programs e*ternal routines would 'e used e*tensivel&. However, additional set6up statements, including an external declaration and an inter&ace bloc., are re@uired. The definition and use of e*ternal routines is not addressed in this chapter.
15.!
%rguments
8hen writing and using /ortran su'programs, it is t&picall& necessar& to provide information to and5or o'tain results from the functions or su'routines. This information, in the form of varia'les, is referred to as an argument or arguments. The argument or arguments in the calling routine is referred to as actual arguments and the argument or arguments in the function or su'routine are referred to as &ormal arguments. The formal arguments ta(e on the values that are passed from the calling routine. The onl& wa& to transfer values in to or out of a function or su'routine is through the arguments. +ll other varia'les are independent and isolated.
1-.3.1
4rgument ,ntent
$u'programs often return values '& altering or update the some of the arguments. 8hen passing a varia'le, the information 3value or values4 can 'e passed into the function or su'routine. This is referred to as ,intent3in42. -f the varia'le is to 'e set '& the su'routine, that is referred to as ,intent3out42. -f the varia'le contains a value or values 3i.e., an arra&4 that are to 'e passed into the su'routine and altered in some wa& '& the su'routine and returned 'ac( to the calling routine, that is referred to as ,intent3inout42.
15.$
3ariable 'co"e
The varia'le scope refers to where a given varia'le can 'e accessed. $cope rules tell us if an entit& 3i.e., varia'le, parameter, and5or function4 is visi'le or accessi'le at certain places. .laces where an entit& can 'e accessed or visi'le is referred as the scope of that entit&. The varia'les defined in a su'program is generall& not visi'le to the calling routine. Thus a varia'le x in the calling routine is different than a varia'le x in the su'program.
15.5
7sing Functions and 'ubroutines
=efore a function or su'routine can 'e used, it must 'e defined or written. <nce defined, the su'routine or function can 'e used or called. + function is called '& using its name as we have done with the intrinsic functions. 8hen a program uses a su'routine it is called with a call statement.
11B
:hapter 11 M $u'programs
1-.-.1
4rgument Passing
8hen using functions and5or su'routines, information 3values, varia'les, etc.4 are t&picall& passed to or from the routines. +rgument association is a wa& of passing values from actual arguments to formal arguments. -f an actual argument is an e*pression, it is evaluated and passed to the corresponding formal argument. -f an actual argument is a varia'le or constant, its value is passed to the corresponding formal argument. There must 'e a one6to6one correspondence 'etween the actual argument 3calling routine4 and the formal argument 3su'routine5function4. The arguments in the call are matched up to the arguments in the su'routine '& position. Each of the arguments is matched '& position. The names of the varia'les do not need to match, however the data t&pes must match. Ca**ing 5outine
... call example (x, y, z) ...
#u3routine
... subroutine example (a, b, c) ...
<ther varia'les in either the calling routine or the su'routine are isolated from each other. +s such, the same varia'le name can 'e re6used in 'oth the calling routine and the su'routine 3and refer to different values4.
15.0
Functions
+ function is a special t&pe of /ortran su'program that is e*pected to return a single result or answer. + function will t&picall& accept some (ind of input information and 'ased on that information, return a result. The two t&pes of /ortran functions are descri'ed in the following sections.
1-.&.1
,ntrinsic %unctions
+s descri'ed previousl&, an intrinsic &unction is a 'uilt6in function that is alread& availa'le. $ome of the intrinsic functions alread& descri'ed include sin(), cos(), tan(), real(), int(), and nint(). + more comprehensive list is contained in +ppendi* ;.
110
1-.&.2
9ser3De=ine' %unctions
+ user6defined function are functions that a written '& the user for specific or speciali?ed re@uirements. The general form of a user6defined function is a follows#
<type> function <name> ( <arguments> ) <declarations> <body of function> <name> = expression return end function <name>
The Zt&pe[ is one of the /ortran data t&pesP real, integer, logical, character, or comple*. -t is possi'le to place the t&pe declaration on a separate line from the functions statement. The information, in the form of arguments, is passed from the calling routine to the function. Each of the passed arguments must 'e declared and the declaration must include the t&pe and the intent. The arguments in the calling routine and the function must match and are matched up '& position. +n e*ample function to convert a /ahrenheit temperature to :elsius temperature would 'e as follows#
real function fahr_to_celsius(ftemp) real, intent(in) :: ftemp fahr_to_celsius = (ftemp 32.0) / 1.8 return end function fahr_to_celsius end program quiz
8hich, given a /ahrenheit temperature, will return the :elsius temperature. The single input argument, &temp, is declared to 'e a real value and ,intent3in42, which means that the value is e*pected to 'e coming into the function and can not 'e changed. The final value is returned to the calling routine '& assigning a value to the function name, &ahr/to/celsius, in this e*ample.
1-.&.2.1
i'e "==ects
+ side$e&&ect is when a function changes one or more of its input arguments. $ince the arguments can 'e declared as ,intent3out42 or ,intent3inout42, the function could change the arguments. -n general, this is consider poor practice and should 'e avoided. None of the e*amples in this te*t will include or utili?e side6effects.
15.5
'ubroutines
+ su'routine is a /ortran su'program that can accept some (ind of input information and 'ased on that information, return a result or series of results.
120
:hapter 11 M $u'programs The general form of a su'routine is a follows#

subroutine <name> ( <arguments> ) <declarations> <body of subroutine> return end function <name>
The information, in the form of arguments, is passed from the calling routine to the function. Each of the passed arguments must 'e declared and the declaration must include the t&pe and the intent. The arguments in the calling routine and the su'routine must match and are matched up '& position. /or e*ample, given the following simple program to find the sum and average of three num'ers.
program subExample implicit none real :: x1=4.0, y1=5.0, z1=6.0, sum1, ave1 real :: x2=4.0, y2=5.0, z2=6.0, sum2, ave2 call smave(x1, y1, z1, sum1, ave1) write(*,'(a,f5.1,3x,a,f5.1)') "Sum=", sum1, "Average=", ave1 call smave(x2, y2, z2, sum2, ave2) write(*,'(a,f5.1,3x,a,f5.1)') "Sum=", sum2, "Average=", ave2 contains subroutine smave (a, b, c, sm, av) real, intent(in) :: a, b, c real, intent(out) :: sm, av sm = a + b + c av = sm / 3.0 return end function smave end program subExample
The arguments in the first call 3x1, %1, 01, sum1, and a'e14 are matched up to the arguments in the su'routine 3a, b, c, sm, and a'4 '& position. That is, the x1 from the call is matched with the a in the su'routine. The arguments in the second call 3x2, %2, 02, sum2, and a'e24 are again matched up to the arguments in the su'routine 3a, b, c, sm, and a'4 '& position. 8hile the names of the varia'les do not need to match, the data t&pes must match. Faria'les declared in a function or su'routine are not the same as varia'les in the calling routine. This is true, even if the& are the same name\
121
15.9
,xam"le
-n this e*ample we will write a /ortran program to simulate the dice game of Twent&6$i*10 which is single pla&er 'etting game with 10 dice. The main program will determine how man& games to pla&, trac( the count of games won and lost, and displa& some win5loss statistics. + su'routine will 'e used to pla& the Twent&6$i* game. The su'routine will 'e called as man& times as re@uested. The su'routine, twenty5six67, will pla& the game dice game Twent&6$i*. To pla& the game, the pla&er rolls the dice 31 to D4 and this initial roll is used as the ,point2 num'er. Then the pla&er throws the ten dice 1 times. The score is the num'er of times that the point num'er is thrown. + random num'er 'etween 1 and D will 'e used for each dice roll. The routine will determine the pa&out 'ased on the point count using the following ta'le#
Point Count -. or )ess -/ 01 03 04 0& /. Other Payout -. ' 2 ' 1 4 -. .
The su'routine should displa& the dice 3all 10 dice for each of 1 rolls4, point count, game result, pa&out. /or e*ample, if the point was D, the su'routine might displa& the following#
Point: 6 Roll: 1 Roll: 2 Roll: 3 Roll: 4 Roll: 5 Roll: 6 Roll: 7 Roll: 8 Roll: 9 Roll: 10 Roll: 11 Roll: 12 Roll: 13 Point Count: Game Result: Dice: Dice: Dice: Dice: Dice: Dice: Dice: Dice: Dice: Dice: Dice: Dice: Dice: 22 LOSS 4 1 3 5 4 3 6 4 4 5 2 1 6 6 6 2 6 6 1 6 1 4 6 3 1 4 5 3 6 4 6 4 5 3 2 1 2 6 4 3 3 4 1 4 5 6 4 1 2 4 5 5 0 3 4 5 4 5 6 1 1 1 4 1 4 3 1 1 3 6 3 5 5 4 4 1 3 5 3 1 4 2 6 6 3 5 4 3 1 3 1 5 3 4 1 2 1 3 6 6 1 2 6 6 3 3 2 5 4 5 3 5 2 5 1 5 6 3 2 6 4 4 5 4 5 5 4 1 1 5 5
Payout =
/or this e*ample, the main will trac( the games won and lost.
10 /or more information, see# http#55homepage.ntlworld.com5dice6pla&5Games5Twent&$i*.htm
122
1-.7.1
The program will displa& an initial header and get the num'er of games to pla&. $pecificall&, we will need to prompt for the count of games and verif& that the count is 'etween 2 and 1,000,000 3ar'itraril& chosen4. Then, the program will call the twenty5six67 su'routine count times. +fter each game, the main will update the count of games won. The main will also trac( the pa&out and 'an( value status, which is initiali?ed to 100 3chosen ar'itraril&4 and updated after each game is pla&ed. +n e*ample main is provided as follows#
program diceGame !----------------------------------------------------------! Fortran program to simulate a dice game of Twenty-Six ! The main program: ! displays appropriate headers ! obtains and checks number of games to play ! loops to play 'count' number of games times implicit none integer, parameter :: initial_bank=100 integer :: num_games, games_won=0, games_lost=0 integer :: i, payout, bank integer, dimension(13,10) :: dice real :: win_pct write (*, '(/a/a/)') & "--------------------------------", & "Dice Game ""Twenty-Six"" Simulator." do write (*, '(2x, a )', advance = "no") & "Enter number games to simulate: " read (*,*) num_games if (num_games >= 1 .and. num_games <= 1000000) exit write (*, '(2x, a)') "Error, number of ", & "games must be between 1 and 1000000." write (*, '(2x, a)') "Please re-enter." end do bank = initial_bank call random_seed() do i = 1, num_games bank = bank - 1 call twentySix (payout) if (payout > 0) then games_won = games_won + 1 else games_lost = games_lost + 1 end if
12
bank = bank + payout end do win_pct = ( real(games_won) / real(num_games) ) * 100.00 write (*,'(/a,/a/,3(2x,a,i9/),2(2x,a,i8/),2x,a,f4.1,a)') "------------------------------------------------" "Games Statistics:", "Game Count: ", num_games, "Games Won: ", games_won, "Games Lost: ", games_lost, "Initial Bank: ", initial_bank, "Final Bank: ", bank, "Win Percentage: ", win_pct, "%" contains ! ********************************************************* ! subroutine(s) goes here... ! ********************************************************* end program diceGame & & & & & & & &
)efer to +ppendi* : for additional information regarding the random num'er generation and initiali?ation of the 'uilt6in random num'er generator.
1-.7.2
$ince the main is provided, the algorithm will focus on the twent&6si* game. $ince the 'uilt6in random num'er generator provides random num'ers 'etween 0.0 and 1.0, the& will need to 'e scaled and converted to an integer 'etween 1 and D 3for a dice4. The initial point value must first 'e esta'lished followed '& a loop to throw the ten dice 1 times in accordance with the game rules. The results will 'e stored in a two6dimensional arra&. 8hile not strictl& re@uired, it does provide an additional e*ample of how to use a two6dimensional arra&. /inall&, the pa&out will 'e determined 'ased on the game rules.
! ! ! ! ! ! Randomly select a number from 1 to 6 as the "point" number Throw ten dice 13 times results go into dice(13,10) array Score is the number of times that the point number is thrown determine payout
12!
1-.7.3
De6elop the Program

! ********************************************************* ! Subroutine to simulate twenty-six game. ! Randomly select a number from 1 to 6 as the point number ! Throw ten dice 13 times ! results go into dice(13,10) array ! Score is the number of times that the point number is thrown subroutine twentySix (payout) implicit none integer, dimension(13,10) :: dice integer, intent(out) :: payout integer :: point, pnt_cnt real :: x integer :: i, j ! determine point call random_number(x) point = int(x*6.0) + 1 roll dice pnt_cnt = 0 do i = 1, 13 do j = 1, 10 call random_number(x) dice(i,j) = int(x*6.0) + 1 if (dice(i,j) == point) pnt_cnt = pnt_cnt + 1 end do end do ! determine payout select case (pnt_cnt) case (6, 10) payout = 10 case (13,27) payout = 5 case (26) payout = 4 case (28) payout = 6 case (29) payout = 8
121
case (30) payout = 10 case default payout = 0 end select write (*,'(/,5x,a,/,5x,a,i2,/,5x,a,i2)') "--------------------------------------", "Point: ", point do i = 1, 13 write (*,'(8x, a, i2, 2x, a, 10(2x, i1),/)', advance="no") "Roll: ", i, "Dice: ", (dice(i,j), j=1,10) end do write (*,'(/,5x,a,i2)') "Point Count: ", pnt_cnt if (payout > 0) then write (*,'(5x,a,i2)') "Game Result: WIN else write (*,'(5x,a,i2)') "Game Result: LOSS end if & Payout = ", payout Payout = ", payout & & &
& &
write (*,'(5x,a,i6)') "Bank:", bank return end subroutine twentySix
1-.7.4
/or this pro'lem, the testing would involve e*ecuting the program using a file with a set of num'ers where the correct results are either (nown ahead of time or can 'e calculated '& hand in order to verif& that the results are accurate.
15.9
,xercises
1-.;.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat are the two t&pes of /ortran su'programsN
12D
:hapter 11 M $u'programs 24 How man& values does a user6defined function t&picall& returnN 4 -n the function call, ans = power(x, y), what are x and y are calledN !4 -n the function heading, integer function power(a, b), what are a and b are calledN 14 -n the function, integer function power(a, b), what is the t%pe of the value returnedN D4 -s it possi'le to pass integer arguments to a real function 3&es5no4N A4 The su'program section 3where functions and su'programs are defined4 is mar(ed '& what (e&wordN B4 8hat is the output of the following function#
integer function power(a, b) integer, intent(in) :: a, b power = a ** b return end function power
a4 with the input of a U 2 and b U N '4 with the input of a U and b U 2N 04 Given the following programN
program quiz implicit none real :: temp=80.0, temp1=50.0, temp2 write (*, '(f5.2, 2x, f5.2)') temp, temp1 temp2 = fahrToCelsius(temp1) write (*, '(f5.2, 2x, f5.2)') temp, temp2 contains real function fahrToCelsius(temp) real, intent(in) :: temp fahrToCelsius = (temp 32.0) / 1.8 return end function fahrToCelsius end program quiz
a4 8hat is the name of the functionN '4 -s the a'ove program correct 3&es5no4N c4 ;oes the varia'le temp in the main and the varia'le temp in the function refer to the same valueN 12A
:hapter 11 K $u'programs d4 8hat is the outputN 104 8hat is meant '& the term 'ariable scopeN 114 8hat is the correct intent for the following situations# a4 + varia'le passed to a function that will not 'e changed in the function. '4 + varia'le that will 'e set in the su'routine and returned. No value is passed in. c4 + varia'le that will 'e passed into a su'routine, updated, and returned 'ac( to the calling routine. 124 8hat is a meant '& the term side$e&&ectN
1-.;.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the dice game program e*ample, compile, and e*ecute the program. Test the program '& pla&ing it for a series of rounds. Ensure the scoring is correct. 24 8rite a main program and an integer /ortran function, g'eries67, to compute the following geometric series#
n 1
g =
xn
n= 0
= 1 + x + x 2 + x! + + x( n1 )
The arguments for the call, in order, are as followsP n 3integer value4. The function should return an integer result 3of the formula 'ased on the n value4. The main should call the function with several different values. 4 8rite a main program and a real function, harmonic8ean67, to compute the harmonic mean of a series of real num'ers. The real num'ers are pass to the function in an arra& along with the count. harmonic mean = N
1 1 1 + + ... + x1 x 2 xN
The arguments for the call, in order, are as followsP arra& of num'ers 3with count real values4, count 3integer4. The function should return an real result 3of the formula4. The main should call the function with several different values.
12B
!4 8rite a main program and a su'routine, %ircle'tats67, that, given an arra& containing a series of circle diameter7s 3real values4, will compute the area of each circle in a series of circles and store them into a different arra& 3real values4. The su'routine should also compute the real average of the circle areas. The arguments for the call, in order, are as followsP circle diameter7s arra& 3count real values4, circle areas arra& 3count real values4, count 3integer4, areas average 3real4. The main program should declare the arra& and initiali?e the arra& with a series of values for circle areas. The program results should 'e verified with a calculator. 14 8rite a main program and a su'routine, 9ead%oord67, to read an 3x, y, z4 coordinate from the user. The su'routine must prompt for and read 3x, y z4 and ensure that the x, y, and z values are 'etween 0 and 100 3inclusive4. The values ma& 'e prompted for and read together, 'ut prompt should leave the cursor on the same line. The su'routine should re6prompt for all three if the input data is not correct. -f the user provides valid data, the 3x, y, z4 values should 'e returned with a logical for valid data set to true. -f the user does not provide valid data entr& after three tries, the su'routine should displa& an error message and a set the logical for valid data to &alse. The arguments for the call, in order, are as followsP x value 3integer4, y value 3integer4, z value 3integer4, and valid data flag 3logical value4. The main program should call the su'routine three times and displa& the results for each call. D4 8rite a main program and a su'routine, 'tats67, that, given an arra& containing a series of num'ers 3real values4, will find and displa& the following real valuesP minimum, median, ma*imum, sum, and average. The displa& must use a formatted write34. The real values will not e*ceed 100.0 and should displa& three digits decimal values 3i.e., nnn.xxx4. The arguments for the call, in order, are as followsP arra& of num'ers 3count real values4, count 3integer4. The main program should populate the arra& with random num'ers and call the su'routine.
120
1 0
10
#eri)ed #ata Ty"es
+ derived data t&pe is a user6defined com'ination of the intrinsic data t&pes. The derived data t&pes are a convenient wa& to com'ine or group varia'les a'out a particular item. /or e*ample, a 7student7 might include a name, identification num'er, final score, and grade. Each of these pieces of information can 'e represented with individual varia'les 3as outlined in previous section4 as follows#
character(50) :: name integer :: id real :: score character(2) :: grade
However, for multiple students, multiple sets of varia'les would 'e re@uired. This can 'ecome cum'ersome and confusing. =& using a derived data t&pe, these separate pieces of information can 'e more easil& grouped together. The details on defining, declaring and using derived data t&pes are provided in the following sections.
10.1
#efinition
=efore a derived data t&pe can 'e used, it must 'e defined. The definition will esta'lish the pieces of information will 'e grouped together. Each piece of information included in the definition is referred to as a component.
type type_name <component definitions> end type type_name
/or e*ample, to declare the student t&pe descri'ed previousl&, the following declaration would 'e appropriate#
type student character(50) :: name integer :: id real :: score character(1) :: grade end type student
The indentation is not re@uired, 'ut does ma(e the definition easier to read. Each of the fields 3name, id, score, grade4 are called components. These components together ma(e up the information for a 7student7. The t&pe definition is re@uired onl& once at the 'eginning of the program. <nce defined, the t&pe definition can not 'e changed. Iore specificall&, additional components can not 'e added unless the definition is updated and program is recompiled. 1 1
:hapter 1D K ;erived ;ata T&pes This definition will esta'lish a template as follows# student name id score grade <nce defined, the template can 'e used to declare varia'les. Each varia'le declared with this definition will 'e created 'ased on the definition which includes the these four components.
10.
#eclaration
type (<type_name>) :: <variable_name(s)>
<nce a derived data t&pe is defined, varia'les using that definition can 'e declared. The general format for a declaration is as follows# /or e*ample, to declare two students, the following declaration could 'e used#
type (student) :: student1, student2
This declaration will declare two varia'les, student1 and student2, each with the set of components defined in the t&pe definition. The definition can 'e thought of as the coo(ie cutter and the declaration is the coo(ie. <nl& after a varia'le has 'een declared, can values 'e set for that varia'le.
10.!
%ccessing Com"onents
<nce some varia'les using the derived data t&pe have 'een declared, the individual components can 'e accessed. /irst the varia'le name is specified, followed '& a ,c2 3percent sign4, and then the component name. The general format is#
<variable_name>%<component_name>
/or e*ample, to set all components for the student student1, the following
student1%name = "Joseph" student1%id = 1234 student1%score = 99.99 student1%grade = "A"
Each component for student1 is set individuall&. Not ever& component must 'e set. <f course, as with other varia'les, an component that has not 'een set can not 'e used.
1 2
:hapter 1D M ;erived ;ata T&pes This previous declaration and these assignments will esta'lish a varia'le as follows# student name id score grade
Joseph 1234 99.99 A
-t is possi'le to assign all components to another varia'le of the same derived data t&pe. /or e*ample, to set student2 to 'e the same as student1, an assignment is used as follows#
student2 = student1
This will cop& all components from the varia'le student1 into the varia'le student2 3since 'oth student1 and student2 are of the same derived data t&pe4.
10.$
,xam"le &ne
-n this e*ample, we will write a simple program to read two times from the user, time one and time two, and calculate the sum of the two times. /or this e*ample, the time will consist of hour, minutes, seconds in 2!6hour format. /or this e*ercise, the hours ma& e*ceed 2 when the times are summed. The program should declare the appropriate varia'les using a derived data t&pe, use a su'routine to read a time 3which should 'e called twice4, and another su'routine to calculate the sum of the times. The su'routine to read the times must perform appropriate error chec(ing. The main should displa& 'oth the times and the final time sum.
1&.4.1
The main is e*pected to define the appropriate derived data t&pe for time, declare some varia'les of that t&pe and call the su'routines. The first su'routine will read a time from the user which will consist of hour, minutes, and seconds in 2!6hour format. This su'routine will 'e called twice. The second su'routine will add the times together and provide a result. The first su'routine to read a time from the user is e*pected to perform error chec(ing on the data entered '& the user. $pecificall&, this re@uires that hours range from 0 to 2 , minutes range from 0 to 10, and seconds range from 0 to 10. Falues outside these ranges, D0 seconds for e*ample, are not valid. /or this simple e*ample, we will re6prompt for incorrect data entr& 3until correct data is provided4. The second su'routine will add the two times and must ensure that the correct ranges for seconds and minutes are maintained. 8hen adding the two times, it is possi'le to add the seconds, minutes, and hours. However, if the sum of the two seconds values e*ceeds D0, the seconds must 'e adEusted and the minutes must 'e updated accordingl& 3add one e*tra minute4. This applies to the minutes as well. However, when added in this e*ercise, the final time sum hours ma& e*ceed 2 hours. /or e*ample, given time one as 1! hours, !A minutes and 22 seconds 3i.e., 1!#!A#224 and time two as 1B hours, 22 minutes, and 10 seconds, 3i.e., 1B#22#104, the total time would 'e hours, 10 minutes and 12 seconds 3i.e., #10#124.
:hapter 1D K ;erived ;ata T&pes
1&.4.2
/or this e*ample there are three partsP the main, the read time su'routine, and the time summation su'routine. The 'asic steps for the main include#
! ! ! ! ! ! ! ! define derived data type for time must include hours, minutes, seconds declare variables, including time1, time2, and timesum display initial header call subroutine to read time1 call subroutine to read time2 call subroutine to add times display results
The 'asic steps for the read time su'routine include#

! subroutine header and appropriate declarations ! loop ! prompt for time ! read time (hours, minutes, seconds) ! check time entered ! if [ hours(0-23), minutes(0-59), seconds (0-59) ] exit ! display error message ! end loop
The 'asic steps for the time summation su'routine include#

! ! ! ! ! ! ! ! ! ! subroutine header and appropriate declarations add the seconds add the minutes add the hours if seconds > 59, then subtract 60 from seconds add 1 to minutes if minutes > 59, then subtract 60 from minutes add 1 to hours
1&.4.3
De6elop the Program

program timeSummation ! define derived data type for time (hours, minutes, seconds) implicit none
1 !
:hapter 1D M ;erived ;ata T&pes

type time integer :: hours, minutes, seconds end type time ! declare variables ! includes time1, time2, and timesum type(time) :: time1, time2, timesum ! display initial header write (*,'(/,a,/)') "Time Summation Example Program." ! call subroutine to read each time call readtime(time1) call readtime(time2) ! call subroutine to add times call addtimes(time1, time2, timesum) ! display results write (*,'(/,a,i2.2,a1,i2.2,a1,i2.2)') "Time One: ", & time1%hours, ":", time1%minutes, ":", time1%seconds write (*,'(a,i2.2,a1,i2.2,a1,i2.2)') "Time Two: ", & time2%hours, ":", time2%minutes, ":", time2%seconds write (*,'(a,i2.2,a1,i2.2,a1,i2.2,/)') "Time Sum: ", & timesum%hours, ":", timesum%minutes, ":", & timesum%seconds contains ! ******************************************************* ! Subroutine to prompt for, read, and check ! a time (hours:minutes:seconds) in 24-hour format. subroutine readtime ( timeval ) type(time), intent(out) :: timeval ! do prompt for time write (*,'(a)',advance="no") "Enter time (hh mm ss): " read time (hours, minutes, seconds) read (*,*) timeval%hours, timeval%minutes, timeval%seconds check time entered if ( timeval%hours >= 0 .and. timeval%hours <= 23.and. timeval%minutes >= 0 .and.
&
&
& & &
1 1

timeval%minutes <= 59 .and. timeval%seconds >= 0 .and. timeval%seconds <= 59 ) exit ! display error message write (*,'(a,/,a)') "Error, invalid time entered.", "Please re-enter time." end do return end subroutine readtime ! ******************************************************* ! Subroutine to add two times. ! Ensures seconds and minutes are within range (0-59) ! Hours may exceed 23 ! subroutine header and appropriate declarations subroutine addtimes ( tm1, tm2, tmsum ) type(time), intent(in) :: tm1, tm2 type(time), intent(out) :: tmsum ! add the seconds, tmsum%seconds tmsum%minutes tmsum%hours = minutes, hours = tm1%seconds + tm2%seconds = tm1%minutes + tm2%minutes tm1%hours + tm2%hours & &
& &
! if minutes > 59, subtract 60 from seconds and add 1 to minutes if (tmsum%seconds > 59) then tmsum%seconds = tmsum%seconds - 60 tmsum%minutes = tmsum%minutes + 1 end if ! if minutes > 59, subtract 60 from minutes and add 1 to hours if (tmsum%seconds > 59) then tmsum%minutes = tmsum%minutes - 60 tmsum%hours = tmsum%hours + 1 end if return end subroutine addtimes end program timeSummation
-f the program does not wor( at first, the comments can aid in determining the pro'lem.
1 D
1&.4.4
/or this pro'lem, the testing would involve e*ecuting the and entering a series of various time values to ensure that the results are correct. -f the program does not wor( initiall&, the functionalit& of each su'routine should 'e chec(ed. The times read from the user can 'e displa&ed to the screen to ensure the& are correct. <nce the times are correct, the add times su'routine can 'e chec(ed. Each of the time sums can 'e displa&ed to help determine where the error might 'e.
10.5
%rrays of #eri)ed #ata
-n addition to declaring single varia'les 'ased on the derived data t&pe definition, it is possi'le to declare an arra& 'ased the derived data t&pe definition. /or e*ample, to declare an arra& named class to hold 0 elements of t&pe student, the following declaration can used used.
type(student), dimension(30) :: class
Each element of the arra& class will 'e of the t&pe student and include each of the defined components 3name, id, score, grade in this e*ample4. /or an arra& of t&pe3student4, the la&out would 'e as follows# class314 name id score grade class324 name id score grade class3 4 name id score grade ... ...
To access elements in the arra&, an inde* must 'e used. +fter the inde*, the desired component would 'e specified. /or e*ample, to set values for the third student, the following statements could 'e used.
class(3)%name = "Fred" class(3)%id = 4321 class(3)%score = 75.75 class(3)%grade = "C"
+s with an& arra&, the inde* can 'e an integer varia'le.
1 A
:hapter 1D K ;erived ;ata T&pes +s with single varia'les, it is possi'le to assign all components of an arra& element to another arra& element or another varia'le of the same derived data t&pe. The following declarations and code could 'e used to swap the location of the fifth student and the eleventh student.
type student character(50) :: name integer :: id real :: score character(1) :: grade end type student type(student), dimension(30) :: class type(student) :: temp temp = class(5) class(5) = class(11) class(11) = temp
This code fragment will cop& all components from the fifth arra& element 3of t&pe t&pe student4 into a temporar& varia'le 3also of t&pe student4. Then, the eleventh arra& element can 'e copied into the fifth arra& element 3thus overwriting all previous values4. +nd, finall&, the eleventh arra& element can 'e set of the original values from the fifth arra& element which are held in the temporar& varia'le.
10.0
,xam"le T*o
-n this e*ample, we will write a simple program to perform some processing for students. The student information will 'e stored in an arra& of derived data t&pes. There will 'e no more than 10 students per class. The main will call a su'routine to read student information 3name and score4 and another su'routine to set the student grades. /inall&, the main will call a function to calculate the class average. The main will displa& the average. )outines for displa&ing the students are left as an e*ercise.
1&.&.1
The main is e*pected to define the appropriate derived data t&pe for student, declare some varia'les of that t&pe and call the su'routines. The first su'routine will read student information including a name 3up to D0 characters4 and score from the user. Names and scores should continue to 'e read until a 'lan( name is entered. The score value must 'e 'etween 0.0 and 100.0 3inclusive4. /or this simple e*ample, we will re6prompt for incorrect data entr& 3until correct data is provided4. The routine must return the count of students entered. The second su'routine set the grades 'ased on the following standard scale. + +[U00 = B0 6 B0 : A0 6 A0 ; D0 6 D0 / ZU10
8hen determining the final grade, the program should round up when appropriate. The main will call a function to calculate and return the average of the scores. +dditionall&, the main will displa& the final average.
1 B
1&.&.2
/or this e*ample main part for the main include declaration, displa& header, call read time su'routine, and the call the time summation su'routine. The 'asic steps for the main include#
! ! ! ! ! ! ! ! ! define derived data type for student must include name, id, grade declare variables includes array for up to 50 students display initial header call subroutine to read student information call subroutine to set grades use function to calculate average of scores display average
The 'asic steps for the read student information su'routine include#
! subroutine header and appropriate declarations ! loop ! prompt for student name ! read name ! if name is empty, exit loop ! loop ! prompt for student score ! read score ! check score entered ! if [score is between 0.0 and 100.0, inclusive] exit ! display error message ! end loop ! update count of students ! place values in student array ! end loop
The 'asic steps for the set grades su'routine include#

! subroutine header and appropriate declarations ! loop ! read score / set grade ! 90 A; 80 - 89 B; 70 79 C; 60 - 69 D; 59 F ! end loop
8hen determining the final grade, the nearest integer intrinsic function, nint34, can 'e used to perform the appropriate rounding. The 'asic steps for the calculate average score function include#
! ! ! ! ! function header and appropriate declarations loop sum scores end loop calculate and return average
1 0
:hapter 1D K ;erived ;ata T&pes /or convenience, the steps are written a program comments.
1&.&.3
De6elop the Program

program classScores ! define derived data type for student, includes name, id, grade implicit none type student character(60) :: name real :: score character(1) :: grade end type ! declare variables, including array for up to 50 students type(student), dimension(50) :: class integer :: count real :: average ! display initial header write (*,'(/,a,/)') "Student Information Example Program." ! call subroutine to read student information call readStudents (class, count) ! call subroutine to set grades call setStudentGrades (class, count) ! use function to calculate average of scores average = classAverage (class, count) ! display average write (*,'(/,a, f5.1)') "Final Class Average: ", average contains ! ******************************************************* ! Subroutine to read student information (name and score). ! A blank name will stop input ! The score must be between 0.0 and 100.0 (inclusive) subroutine readStudents (class, count) type(student), dimension(50), intent(out) :: class integer, intent(out) :: count = 0 character(60) :: tempname real :: tempscore
1!0
do prompt for student name and read name write (*,'(a)',advance="no") "Enter Student Name: " read (*,'(a60)') tempname if name is empty, exit loop if ( len_trim(tempname) == 0 ) exit do prompt for student score and read score write (*,'(a)',advance="no") "Enter Student Score: " read (*,*) tempscore check score entered if ( tempscore >= 0.0 .and. tempscore <= 100.0 ) exit display error message write (*,'(a,/,a)') "Error, invalid score.", "Please re-enter time." end do
&
&
& &
update count of students and place in student array count = count + 1 class(count)%name = tempname class(count)%score = tempscore end do
return end subroutine readStudents ! ******************************************************* ! Subroutine to set student grades. ! 90 A; 80 - 89 B; 70 79 C; 60 - 69 D; 59 F subroutine setStudentGrades (class, count) type(student), dimension(50), intent(inout) :: class integer, intent(in) :: count integer :: i ! check each score / set each grade do i = 1, count select case ( nint(class(i)%score) ) case (90:)
1!1

class(i)%grade case (80:89) class(i)%grade case (70:79) class(i)%grade case (60:69) class(i)%grade case (:59) class(i)%grade end select end do return end subroutine setStudentGrades ! ******************************************************* ! Function to calculate average score. real function classAverage (class, count) type(student), dimension(50), intent(in) :: class integer, intent(in) :: count integer :: i real :: sum = 0.0 ! sum scores do i = 1, count sum = sum + class(i)%score end do = "A" = "B" = "C" = "D" = "F"
! calculate and return average classaverage = sum / real(count) return end function classAverage end program classScores
-f the program does not wor( at first, the comments can aid in determining the pro'lem.
1&.&.4
/or this pro'lem, the testing would involve e*ecuting the program and entering a series of student data values to ensure that the results are correct. -f the program does not provide the correct results, each of the su'routines and the function results should 'e verified individuall&. Each can 'e chec(ed '& displa&ing the intermediate results to the screen. -n this manner, the su'routine or function that is not wor(ing correctl& can 'e @uic(l& identified. <nce identified, some additional write statements inside the su'program can 'e used to help identif& the specific pro'lem. The testing and de'ugging process is left to the reader as an e*ercise.
1!2
10.5
,xercises
1&.2.1
Quiz Questions
=elow are some @ui? @uestions. 14 +n item in a derived data t&pe is calledN 24 How are components of a derived data t&pe accessedN 4 ;efine a derived data t&pe, circle, to store information a'out a circle. Iust include a circle name 3ma* 20 characters4, si?e 3radius C a real value4 and the position in 6dimensional space 3x, y, and z Q all integer values4. !4 8rite the declaration necessar& to declare two varia'les named ring1 and ring2 of t&pe circle 3from previous @uestion4. 14 ;efine a user6defined t&pe, planet, to store information for a planet. -nclude a name 311 characters4, radius 3real value4, area 3real value4, and volume 3real value4. +dditionall&, write the declaration necessar& to declare two varia'les named earth and mars of t&pe planet+ D4 ;efine a user6defined t&pe named date for processing dates consisting of a month name 310 characters4, month 3integer4, date of month 3integer4, and &ear 3integer4. A4 =ased on the previous @uestion a4 8rite the statements to declare a varia'le named today and set it to 125215201 . '4 8rite the statements to declare a varia'le named newyear and set it to Januar& 1, 2011.
1&.2.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the time summation program, compile and e*ecute the program. Test on several sets of input including the e*ample in the e*planation. 24 8rite a /ortran program to read and displa& information a'out a set of planetar& 'odies. The program should read the information from a file, allow the user to select a displa& option, and call the appropriate routine to displa& that information. The main program should call a series of su'routines as follows#
$u'routine read"lanets67 to prompt for file name of planets file, open the file 3including error chec(ing4, and read file into an arra&. Three errors are allowed, 'ut if a fourth error is made, the routine should terminate the program. $u'routine calc"lanet&rea67 to calculate the planet area 'ased on the diameters.
1!

/unction get:ser*ption67 to displa& a list of options, read the selection option. $u'routine display"lanet8in8ax67 to displa& the minimum and ma*imum 'ased on an option as follows#

<ption 314 Q $mallest and 9argest .lanets 3'ased on area4 <ption 324 Q :oldest and Hottest .lanets 3'ased on average temperature4 <ption 3 4 Q .lanets with $hortest and 9ongest ;a&s 3'ased on da& length4
$u'routine print"lanets'ummary67 to displa& the planet name, distance from sun, and planet si?e.
The output should 'e formatted as appropriate. Test on several sets of input values and verif& that the output is correct for the given input values. 4 Iodif& the planet program 3from previous @uestion4 to sort the planets 'ased on the radius. Test on several sets of input values and verif& that the output is correct for the given input values. !4 T&pe in the time class scores program, compile and e*ecute the program. Test on several sets of input values. 14 Iodif& the class scores program to assign grades 'ased on the following scale#
% 09'& D ,09$0 C9 $09$2 C $!9$, CA $$9$& )9 .09.2 ) .!9., )A .$9.& 19 &09&2 1 1A
&!9&, &$9100
Test on several sets of input values and verif& that the output is correct for the given input. D4 Iodif& the class scores program to read the name and score file a file. $hould include prompting for a file, opening the file, and reading the file contents into the class arra&. -n order to complete this e*ercise, create a file containing some random names and scores. Test on several sets of input values.
1!!
15
6odules
/or larger programs, using a single source file for the entire program 'ecomes more difficult. /ortunatel&, large programs can 'e split into multiple source files, each file can contain a su'set of su'routines and5or functions. There must 'e a main or primar& source file that includes the main program. The secondar& file or files is referred to as a module or modules. +dditionall&, the modules can then 'e more easil& used in other, different programs ensuring that the code can 'e easil& re6used. This saves time and mone& '& not re6writing routines. This section provided a description of the formatting re@uirements and an e*ample of how to set6up the modules.
15.1
6odule #eclaration
module <name> <declarations> contains <subroutine and/or function definitions> end module <name>
The secondar& source file or module must 'e formatted in a specific manner as follows#
/or e*ample, to declare a module named stats that includes some a function to find the average of the num'ers in an arra&, the following module declaration might 'e used.
module stats ! note, no global variables used in this module contains ! ************************************************************* ! Simple function to find average of len values in an array. real function average(array, len) real, intent(in), dimension(1000) :: array integer, intent(in) :: len integer :: i real :: sum = 0.0 do i = 1, len sum = sum + array(i) end do average = sum / real(len) end function average end module stats
1!1
:hapter 1A K Iodules This e*ample assumes the real arra& contains len num'er of values up to a ma*imum of 1000 values.
15.
7se 'tatement
<nce the module is defined, the routines from the module can 'e included '& using the use statement. The use statement or statements must 'e at the 'eginning of the applica'le source file. /or e*ample, 'elow is a simple main that uses the previous stats module.
program average use stats implicit none real, dimension(1000) :: arr integer :: i, count real :: ave ! ----! Initialize array with some values. count = 0 do i = 1, 20 arr(i) = real(i) + 10.0 count = count + 1 end do ! ----! Call function to find average and display result. ave = arraverage(arr, count) write (*, '(/, a, f10.2, /)') "Average = ", ave end program average
The use statement is included 'efore the varia'le declarations. +n& num'er of use statements for defined modules ma& 'e included.
15.!
7"dated Com"ilation Commands
/or a large program that is split 'etween multiple source files, the compilation process must 'e updated. The compilation process refers to the steps re@uired to compile the program into a final e*ecuta'le file. Each module unit must 'e compiled independentl&. This allows the programmer to focus on one module, set of routines, at a time. /urther, for ver& large proEects, multiple programmers can wor( on separate modules simultaneousl&.
1!D
:hapter 1A M Iodules The initial step is to compile each module. +ssuming the module from the earlier section is named stats.f95, the command to compile a module is#
gfortran -c stats.f95
which will read the source file 3stats.f954 and create two new filesP an o'Eect file stats.o and a module file stats.mod. The name of the o'Eect file is 'ased on the name of the source file. The name of the module file is 'ased on the module name. 8hile the& are the same name in this e*ample, that is not a re@uirement. The compile command is re@uired for each module. <nce all the modules are compiled and the .o and .mod files are availa'le, the main file can 'e compiled. This step reads the .o and .mod files for each module and 'uilds the final e*ecuta'le file. /or e*ample, the command to compile the main file for the previous arra& average e*ample is#
gfortran -o main main.f95 stats.o
/or multiple modules, each of the .o files would 'e listed. -n this e*ample, the stats.mod file is read '& the gfortran compiler. 8hile not e*plicitl& listed, the .mod files are re@uired and used at this step.
15.$
6odule ,xam"le Program
The following is an e*ample program to compute the surface area and volume of a sphere. This is a fairl& straightforward pro'lem focusing more on the creation and use of a module for some routines.
12.4.1
This pro'lem will 'e divided into two parts, the main program source file and a secondar& source file containing the su'routines and functions. 8hile this pro'lem is not large enough to re@uire splitting into multiple files, it is split to provide an e*ample of how to use modules. )ecall that the formulas for the surface area and volume of a sphere are as follows# surface&rea = 4.0 volume = 4.0 !.0 radius2
radius !
The value of > will 'e defined as a constant and set to .1!110. /or this e*ample, the main program will displa& some initial headers and read the radius from the user. <nce the radius is read, the main program will call functions for the surface area and the volume and a su'routine to displa& the results.
1!A
:hapter 1A K Iodules
12.4.2

! display header and read radius ! call functions for sphere volume and surface area ! call routine to display formatted results
=ased on the pro'lem definition, the steps for the main are#
The module will contain the functions and su'routine. The first function will compute the sphere volume. The single step is#
! compute the volume of a sphere with given radius. ! sphere volume = [ (4.0 * pi) / 3.0 ] * radius^3
The second function will compute the sphere surface area. The single step is#
! compute the volume of a sphere with given radius ! sphere volume = 4.0 * pi * radius^2
The su'routine will displa& the formatted results.
12.4.3
De6elop the Program
The program is presented in two parts corresponding to the main program and the secondar& module routines. 8hile this e*ample is not reall& long or comple* enough to re@uire multiple files, the program is split in order to provide an e*ample using a separate module file.
12.4.3.1
5ain Program

program sphere use sphereRoutines implicit none real :: radius, spVolume, spSurfaceArea ! ----! Display header and read radius write (*,'(a/)') "Sphere Example Program" write (*,'(a)', advance="no") "Radius: " read (*,*) radius ! ----! Call functions for sphere volume and surface area spVolume = sphereVolume(radius) spSurfaceArea = sphereSurfaceArea(radius)
1!B
:hapter 1A M Iodules
! ----! Call routine to display formatted results. call displayResults(radius, spVolume, spSurfaceArea) end program sphere
The name of module, sphereRoutines in this e*ample, must 'e the name of the secondar& source file.
12.4.3.2
5o'ule Routines
=ased on the algorithms for the two functions and su'routine, the 'elow module program could 'e developed. -n this e*ample, the declaration for > is defined as a glo'al varia'le. This shares the varia'le 'etween all the su'routines and functions in the module. Use of glo'al varia'les is t&picall& limited. This provided an e*ample of an appropriate use of a glo'al varia'le.
! Example secondary source file. module sphereRoutines implicit none ! needed in every module
! Global declarations, if any, go here. real, parameter :: pi = 3.14159 ! ******************************************************** ! Subroutines and functions are included after ! the 'contains'. contains ! ******************************************************** ! Compute the volume of a sphere with given radius. ! sphere volume = [ (4.0 * pi) / 3.0 ] * radius^3 real function sphereVolume (radius) real, intent(in) :: radius sphereVolume = ( ( 4.0 * pi ) / 3.0 ) * radius ** 3 return end function sphereVolume ! ******************************************************** ! Compute the volume of a sphere with given radius. ! sphere volume = 4.0 * pi * radius^2 real function sphereSurfaceArea (radius) real, intent(in) :: radius
1!0
sphereSurfaceArea = 4.0 * pi * radius ** 2 return end function sphereSurfaceArea ! ******************************************************** ! Simple routine to display results. subroutine displayResults(rad, vol, area) real, intent(in) :: rad, vol, area write write write write write (*,'(/, a)') "-------------------------------" (*, '(a)' ) "Results:" (*,'(3x, a, f10.2)') "Sphere Radius = ", rad (*,'(3x, a, f10.2)') "Sphere Volume = ", vol (*,'(3x, a, f10.2, /)') & "Sphere Surface Area = ", area
return end subroutine displayResults ! ******************************************************** end module sphereRoutines
-n a more comple* program multiple module files might 'e used. The grouping should 'e 'ased on the logical relationship of the routines. + more complicated program would re@uire a more comprehensive design effort.
12.4.4
Compile the Program

gfortran -c sphereroutines.f95 gfortran -o modmain modmain.f95 sphereroutine.o
The commands to compile the module file and then the main file are as follows#
The first will create files sphereroutines.o and sphereroutines.mod. The second will read the files modmain.f95 and sphereroutines.o then create the e*ecuta'le modmain.exe file.
12.4.-
/or this pro'lem, the testing would involve e*ecuting the and entering a series of radius values and ensure that the results are correct. -f the the program does not provide the correct results, each of the functions and the su'routines could 'e verified individuall&. Each can 'e chec(ed '& displa&ing the intermediate results to the screen. -n this manner, the su'routine or function that is not wor(ing correctl& can 'e @uic(l& identified. <nce identified, some additional write statements inside the su'program can 'e used to help identif& the specific pro'lem.
110
:hapter 1A M Iodules
15.5
,xercises
12.-.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat is the primar& purpose of using a moduleN 24 -n the main program, what statement is used to include the modulesN 4 -n the secondar& source file, what statements is used to define and name the moduleN !4 How man& main programs are allowedN 14 How man& modules are allowedN D4 -s the contains (e& word needed in a module file 3&es or no4N
12.-.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the arra& average main program and the arra& average module, compile and e*ecute the program. Test on several sets of input including the e*ample in the e*planation. 24 T&pe in the sphere volume and surface area main program and the sphere volume and surface area module, compile and e*ecute the program. Test on several sets of input including the e*ample in the e*planation. 4 Update the planets program form the previous chapter, pro'lem a2, and 'rea( the program into a main file and a module file for the functions and su'routines.
111
112
19
+ecursion
The Google search result for recursion, shows 1ecursion did %ou mean recursionN )ecursion is a powerful general6purpose programming techni@ue and is used for some important applications including search and sorting methods. )ecursion is the idea that a function ma& call itself 3which is the 'asis for the Eo(e4. )ecursion can 'e ver& confusing in its simplicit& and power. The e*amples in this section will not 'e enough in themselves for the reader to o'tain recursive enlightenment. The goal of this section is to provide an introduction to the concept on recursion. The simple e*amples here, which are used introduce recursion, are meant to help demonstrate the form and structure for recursion. Iore comple* e*amples 3than will 'e discussed here4 should 'e studied and implemented in order to ensure a complete appreciation for the power of recursion. The calling process previousl& descri'ed supports recursion without an& changes. + recursive routine must have a recursive definition that includes# 1. 'ase case, or cases, that provide a simple result 3that defines when the recursion should stop4. 2. rule, or set of rules, that reduce toward the 'ase case. This recursive definition is referred to as a recursive relation.
19.1
+ecursi)e 'ubroutines
+ recursive su'routine declaration must 'e preceded '& the (e&word recursive. /or e*ample#
recursive subroutine <name> ( <arguments> ) <declarations> <body of subroutine> return end subroutine <name>
=ased on this declaration the su'routine can call itself. The routine must ensure that it eventuall& stops calling itself. +rguments are passed in the standard wa&. The calling routine does not need an& special declarations in order to call a recursive routine.
11
:hapter 1B K )ecursion
19.
+ecursi)e Print 2inary ,xam"le
This section provides an e*ample recursive su'routine to accept a decimal num'er and print that num'er in 'inar& 3i.e., using 17s and 074. -t is assumed the reader has a 'asic understanding of 'inar&11 representation. This information is summari?ed in the chapter on :omputer <rgani?ation. +dditionall&, there are man& references availa'le on the -nternet.
17.2.1
/or this e*ample, the pro'lem is divided into two parts, the main program and the recursive su'routine. The main program will handle the prompting and reading of the decimal num'er including error chec(ing and re6prompting as needed. The recursive su'routine will displa& the 'inar& value. $ince the error chec(ing is alread& performed, the recursive su'routine will assume valid input. /or more comple* e*amples, the routine ma& need to perform 'asic error chec(ing.
17.2.2
<ne 'asic algorithm to convert a decimal num'er into a 'inar& num'er, is successive integer division '& 2. /or e*ample, given the num'er 1 , 1 divided '& 2 is D with a remainder of 1. Ne*t, the D is divided '& 2 giving with a remainder of 0. +gain, the is divided '& 2 providing a 1 with a remainder of 1. The final 1 is divided '& 2 resulting in a 0 with a remainder of 1. 8ith a final result of 0, the algorithm is completed. The process is shown as follows# 1! = , 2 , = ! 2 ! = 1 2 1 = 0 2 remainder 1 remainder 0 remainder 1 remainder 1
The remainders, alwa&s 0 or 1, represent the 'inar& value. However, the resulting remainders are generated in 'ac(wards order. +s such, the resulting remainders 1, 0, 1, and 1 in this e*ample must 'e reversed for a final value of 11012 3as noted in chapter 24. This process can 'e converted into a recursive relation as follows# print3inary ( n ) =
if n 1 if n > 1
n print3inary ( n / 2 ) output mod ( num ; 2 )
11 /or more information regarding 'inar& representation, refer to# http#55en.wi(ipedia.org5wi(i5=inar&Rnum'er
11!
:hapter 1B M )ecursion This definition assumes that the value of n is positive. The recursive relation can 'e used '& directl& converting the algorithm into code.
17.2.3
De6elop the Program
=ased on the recursive definition, a simple recursive su'routine can 'e developed. -n order to demonstrate the recursive su'routine, a main program is provided that will read a decimal value from user and ensure it is 'etween 0 and 1,000,000, and then call the recursive routine.
! Simple recursive program to print a decimal number in binary program binary implicit none integer :: decimalNumber write (*,'(a/)') "Decimal to Binary Conversion Example" do write (*,'(a)', advance="no") "Enter Decimal Number (0 - 1,000,000): " read(*,*) decimalNumber if (decimalNumber >= 0 .and. decimalNumber <= 1000000) exit & &
write (*,'(a)') "Error, decimal value out of range." write (*,'(a)') "Please re-enter." end do write(*,'(/a, i7, a)', advance="no") & "The decimal value of ", decimalNumber, " is " call printBinary(decimalNumber) write (*,'(/)') contains ! ************************************************************ ! Print binary subroutine. recursive subroutine printBinary(num) integer, intent(in) :: num integer :: i if (num > 1) call printBinary(num/2) write(*,'(i1)', advance="no") mod(num,2) return end subroutine printBinary
111
! ************************************************************ end program binary
The spacing and indentation is not re@uired, 'ut helps to ma(e the program more easil& reada'le. The main program ensures that the recursive routine is not called in invalid values 3i.e., values 04.
17.2.4
/or this pro'lem, the testing would involve e*ecuting the program and entering a series of decimal values and ensure that the results are correct. The 8indows calculator provides simple convert6to6 'inar& function that can 'e used for verification. -f the the program does not provide the correct results, the input to the recursive su'routine should 'e verified 3via write statements4. Ne*t, some additional write statements in the recursive su'routine can 'e added to provide insight into what is 'eing done for each call.
19.!
+ecursi)e Functions
+ recursive function declaration must 'e preceded '& the (e&word recursive. -n addition, the (e&word resu*t must 'e e*plicitl& added to the function declaration. The resu*t (e&word is used to specif& a single varia'le for the return value. $imilar to a standard function, the result varia'le must 'e set to a return value to the calling routine. The function t&pe specifies the t&pe of the result varia'le. /or e*ample#
<type> recursive function <name> (<arg's>) result (<variable>) <declarations> <body of function> <variable> = expression return end function <name>
The main does not need an& special declarations.
19.$
+ecursi)e Factorial ,xam"le
This section provides an e*ample recursive function to computer the mathematical factorial12 function. -t is assumed the reader is familiar with the factorial function.
12 /or more information regarding factorial, refer to# http#55en.wi(ipedia.org5wi(i5/actorial
11D
:hapter 1B M )ecursion
17.4.1

n
The factorial function is mathematicall& defined as follows# n! =
1
1= 1
<r more familiarl&, &ou might see 1\ as# n! = ' 4 ! 2 1 /or this e*ample, the pro'lem is divided into two parts, the main program and the recursive function. The main program will handle the prompting and reading of the n value. This will include error chec(ing and re6prompting as needed. The recursive function will compute and return the factorial value. $ince the error chec(ing is performed performed, the recursive function will assume valid input. /or more comple* e*amples, the function itself ma& need to perform the error chec(ing. +s such, a simple helper function could 'e used to verif& the input value or values 'efore calling the recursive function.
17.4.2

factorial ( n) =
+ t&pical recursive relation for factorial is as follows#
1 n factorial ( n 1 )
if n= 0 if n 1
This definition assumes that the value of n is positive. -t must 'e noted that this function could easil& 'e computed with a loop. However, the reason this is done recursivel& is to provide a simple e*ample of how a recursive function is developed using a familiar mathematical function.
17.4.3
De6elop the Program
=ased on the recursive definition, a simple recursive function can 'e developed. -n order to demonstrate the recursive function, a main program is provided that will read the decimal value from user and ensure it is 'etween 1 and 11, and then call the recursive routine. The recursive function declaration uses an input argument, n, and a result argument, ans, in this e*ample. The input argument must 'e declared as intentDinE in the standard manner. However, the result argument is an out '& definition and will assume the t&pe of the function itself, integer in this e*ample. /or the recursive factorial function, the 'asic algorithm is provided as part of the recursive definition. The e*ample main will read the n value from the user, call the factorial function, and displa& the results.
! Simple recursive function example. program recursionExample implicit none
11A
integer :: num, numFact write (*,'(a/)') "Recursion Example" do write (*,'(a)', advance="no") "Enter N (1-15): " read(*,*) num if (num >= 1 .and. num <= 15) exit write (*,'(a)') "Error, N out of range." write (*,'(a)') "Please re-enter." end do numFact = fact(num) write (*,'(a, i2, a, i10,/)') "Factorial of ", num, & " is ", numFact contains ! ************************************************************* ! Factorial function integer recursive function fact(n) result (ans) implicit none integer, intent(in) :: n if (n == 1) then ans = 1 else ans = n * fact(n-1) end if return end function fact ! ************************************************************* end program recursionExample
The spacing and indentation is not re@uired, 'ut helps to ma(e the program more easil& reada'le. The main program ensures that the recursive routine is not called in invalid values 3i.e., values 04.
17.4.4
/or this pro'lem, the testing would involve e*ecuting the program, entering a num'er, and ensuring that the result is correct. The 8indows calculator includes a factorial function which can 'e used to verif& the result. -f the the program does not provide the correct result, the input to the recursive function should 'e verified 3via write statements4. Ne*t, some additional write statements in the recursive function can 'e added to provide insight into what is 'eing done for each call. 11B
:hapter 1B M )ecursion
19.5
+ecursi)e Factorial Function Call Tree
-n order to 'etter understand recursion, a recursion tree can help show how the recursive calls interact.
main# f U fact314
$tep 10
$tep 1
fact# 1 Y fact3!4
$tep 0
$tep 2
fact# ! Y fact3 4
$tep B
$tep
fact# Y fact324
$tep A
$tep !
fact# 2 Y fact314 fact# return 1
$tep D
$tep 1
Illustration 2: Factorial 1ecursion 3ree
8hen the initial call to factorial function occurs from main, the main will start into the fact67 function 3shown as step 14. $ince the argument of 1 is not a 'ase case, the fact67 function must call fact67 again with the argument of n)1 or ! in this e*ample 3step 24. +nd, again, since ! is not the 'ase case, the fact67 function must call fact67 again with the argument of n61 or in this e*ample 3step 4. This process continues until the argument passed into the fact67 function meets the 'ase case which is when the arguments is e@ual to 1 3shown as step 14. 8hen this occurs, onl& then is a return value provided to the previous call 3step D4. This return argument is then used to calculate the previous multiplication which is 2 times 1 which will return a value to the previous call 3as shown in step A4. This process will continue 3steps B, 0, and 104 until the main has a final answer. $ince the code 'eing e*ecuted is the same, each instance of the fact67 function is different from an& other instance onl& in the arguments and an& local values 3none in this e*ample4.
110
:hapter 1B K )ecursion -t should also 'e noted that the height of the recursion tree is directl& associated with the amount of memor& used '& the recursive function. /or pro'lems where the recursion tree is ver& large, this can have a negative impact on overall performance of a recursive routine.
19.0
,xercises
17.&.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hat are the two re@uirements for a recursive definitionN 24 -n recursion, the case for which a solution is o'tained directl& is called whatN 4 8hat (e&word is re@uired for a recursive su'routineN !4 8hat two (e&words are re@uired for a recursive functionN 14 8hat special re@uirements are re@uired of the calling routine in order to call a recursive su'routine or recursive functionN D4 /or a recursive routine, what would happen if the routine does not stop recursingN A4 :reate a recursion tree for the recursive /i'onnaci function 3as descri'ed in the following suggested proEects section4 with the input of 1 . *ote, the recursive /i'onnaci function re@uires two recursive calls for for the non6'ase case step.
17.&.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the print 'inar& main program and recursive su'routine. Test on several data sets and verif& that the program produces the correct results. 24 T&pe in the factorial main program and recursive funciton. Test on several data sets and verif& that the program produces the correct results.
4 The recursive definition of /i'onnaci function is as follows#
fib ( n ) =
1 1 fib ( n 1 )+ fib ( n 2)
if n= 0 if n= 1 if n 2
:reate a main program to read the n value from the user and ensure it is 'etween 1 and !0. ;evelop recursive function, fi', to recursivel& compute the /i'onnaci num'er 'ased on the provided definition. *ote, the recursive /i'onnaci function re@uires two recursive calls for for the non6'ase case step.
1D0
:hapter 1B M )ecursion !4 ;evelop a recursive su'routine to recursivel& print a star tree. =ased on an initial value, n, the star tree should 'e displa&ed. /or e*ample, for an n value of 1, the program should output something similar to the following#
Recursive Subroutine Program Enter Number of Stars: 5 Star Tree: * * * * * * * * * * * * * * *
:reate a main program to read the n value from the user and ensure it is 'etween 1 and 10. ;evelop recursive su'routine, print'tars67, to recursivel& print the start tree as shown. The su'routine should print one line per call. /or successive recursive calls, the n value passed as an argument should 'e decremented. The 'ased case would 'e one 314 star. 14 8rite a program using a recursive function to determine the num'er of possi'le paths through a two6dimensional grid. The onl& allowed moves are one step to the right or one step down. /or e*ample, given a grid as follows#
0 0 1 2 1 2
start
end Ioving from the starting location, 30,04 in this e*ample, going to the end location, 3 ,24 in this e*ample, can 'e performed in 10 different wa&s. Two, of the ten, different wa&s are shown in the e*ample a'ove. The function must 'e recursive. :reate a main program to read the initial grid coordinates and ensure that the& are valid 3positive values4 and that the end coordinates are greater than the start coordinates. :reate a recursive function, count"aths67, to determine the num'er of possi'le paths through a two6 dimensional grid. The function will accept a start coordinate 3row,col4 and a final end coordinate 3row,col4.
1D1
:hapter 1B K )ecursion D4 The Tower of Hanoi is a mathematical pu??le that consists of three pegs, and a num'er of dis(s of different si?es which can slide onto an& peg. The pu??le starts with the dis(s neatl& stac(ed in order of si?e on one peg, the smallest at the top, thus ma(ing a conical shape. The o'Eective of the pu??le is to move the entire stac( to another peg, o'e&ing the following rules#

<nl& one dis( ma& 'e moved at a time. Each move consists of ta(ing the upper dis( from one of the pegs and sliding it onto another peg, on top of the other dis(s that ma& alread& 'e present on that peg. No dis( ma& 'e placed on top of a smaller dis(.
The following is a recursive definition for the pro'lem#
hanoi ( n ; from ; to ; by ) =
write ( move the disc =rom from to to ) hanoi ( n 1, from ; by ; to ) hanoi ( 1, from ; to ; by ) hanoi ( n 1, by ; to ; from )
if n= 1 if n > 1
:reate a main program to read and validate the num'er of dis(s, n, from the user and ensure it is 'etween 1 and 10. ;evelop recursive function, hanoi, to recursivel& compute a solution to the Tower of Hanoi pro'lem.
1D2
19
Character 'tring 8 >umeric Con)ersions
:haracters string values, such as ,12 2 can not 'e used to perform numeric operations such as addition or multiplication. +s such, for more comple* programs, there is sometimes the need to convert 'etween a character string representing a numeric value and an actual real or integer num'er. These conversions can 'e performed using what is referred to as an internal read or an internal write. =asicall&, the read or write functions and associated format statements can 'e used to perform 'asic conversions. -nstead of reading from an open file, the read and write operations can read and write directl& from and to varia'les. The specified format provides guidance for the conversion result. =ased on the input, a conversion ma& not 'e possi'le. /or e*ample, the character string , .1!2 can 'e converted into the real value of .1!. However, the character string , .1?!2 could not 'e converted since the 7?7 is not a legal numeric value. -f a conversion is not possi'le, an error would 'e generated. -f not handled, such an error would crash the program. -n order to address and handle an& potential errors, the iostat parameter for the read5write operation is used as previousl& descri'ed in the file operations chapter.
19.1
Character 'tring to >umeric Con)ersion
+ character string can 'e converted into an integer or real value using an internal read operation. The string is provided as the input instead of a file unit num'er. The numeric varia'le is provided as the location for the result of the read operation. The format will provide guidance for the conversion. The following is a simple e*ample that will declare two strings and convert the first into an integer value and the second into a real value. +dditionall&, a third string conversion is perform on a invalid numeric string 3to 'etter show the error handling4.
! Example program to use an internal read for ! character / numeric conversion. program cvtExample 1 implicit none integer :: cvtErr character(4) :: iString = "1234" character(7) :: rString = "3.14159" character(7) :: badString = "3.14z59" integer :: iNum1, iNum2 real :: pi, tau write (*,'(a, /)') "Example Conversion Program."
1D
:hapter 10 K :haracter $tring 5 Numeric :onversions

! ---------! Convert string to an integer value. read (iString, '(i10)', iostat=cvtErr) iNum1 if (cvtErr == 0 ) then iNum2 = iNum1 * 2 write (*,'(a, i5, /, a, i5, /)') & "num1 = ", iNum1, "num2 = ", iNum2 else write (*,'(a, /)') "Error, invalid integer string." end if ! ---------! Convert string to an real value. read (rString, '(f17.6)', iostat=cvtErr) pi if (cvtErr == 0 ) then tau = pi * 2.0 write (*,'(a, f5.3, /, a, f5.3, /)') & "pi = ", pi, "tau = ", tau else write (*,'(a, /)') "Error, invalid real string." end if ! ---------! Convert string to an real value. read (badString, '(f12.4)', iostat=cvtErr) pi if (cvtErr == 0 ) then tau = pi * 2.0 write (*,'(a, f5.3, /, a, f6.3)') & "pi = ", pi, "tau = ", tau else write (*,'(a, /)') "Error, invalid real string." end if end program cvtExample1
The specific formats used on the read operations in the e*ample are wider or larger than the e*pected num'er 3which is allowed4. $hould a smaller format 'e used, it would either truncate the value or possi'l& generate a conversion error. To ensure appropriate conversion, the final values should 'e verified against the e*pected result.
1D!
:hapter 10 M :haracter $tring 5 Numeric :onversions +n e*ample of the output for this program is as follows#
Example Conversion Program. num1 = num2 = 1234 2468
pi = 3.142 tau = 6.283 Error, invalid real string.
The multiplication '& 2 for each of the numeric values was performed onl& as an e*ample since multiplication can onl& 'e performed on numeric data t&pes 3i.e., integer, real, or comple*4.
19.
>umeric to Character 'tring Con)ersion
+n integer or real value can 'e converted into a character string using a write operation. The string is provided as the output varia'le instead of a file unit num'er. The numeric varia'le is provided as the input for the write operation. The following is a simple e*ample that will convert an integer into a string and a real into a string. $ome numeric operations are performed on the numeric values and then the resulting strings are concatenated with another string. :oncatenation can onl& 'e performed on character data t&pes.
! Example program to use an internal write for ! character / numeric conversion. program cvtExample2 implicit none integer :: cvtErr character(50) :: str1, str2, msg1, msg2 integer :: iNum=2468 real :: pi = 3.14, tau write (*,'(a, /)') "Example Conversion Program." ! ---------! Convert integer value to a string. iNum = iNum / 100 write (str1, '(i3)', iostat=cvtErr) iNum if (cvtErr == 0 ) then msg1 = "My age is " // str1 write (*,'(a, a)') & "Message 1 = ", msg1 else write (*,'(a, /)') "Error, invalid conversion." end if
1D1

! ---------! Convert real value to a string. tau = pi * 2.0 write (str2, '(f5.3)', iostat=cvtErr) tau if (cvtErr == 0 ) then msg2 = "The value of TAU is " // str2 write (*,'(a, a, /)') & "Message 2 = ", msg2 else write (*,'(a, /)') "Error, invalid conversion." end if end program cvtExample2
+n e*ample of the output for this program is as follows#

Example Conversion Program. Message 1 = My age is 124 Message 2 = The value of TAU is 6.283
<nce the numeric values are converted into strings, the character functions and character operations can 'e used as needed.
19.!
,xercises
1;.3.1
Quiz Questions
=elow are some @ui? @uestions. 14 8hich operation, internal read or internal write, is re@uired to convert a character string containing a numeric valueN 24 8hich operation, internal read or internal write, is re@uired to convert a real value into a character stringN 4 .rovide an appropriate statement to convert the character string sNumU,12 2 into an integer varia'le iNum. The error status should 'e written to the varia'le cvt<rr. "ou ma& assume all varia'les are alread& declared and initiali?ed. !4 .rovide an appropriate statement to convert the integer varia'le iNumU2 ! into a character string sNum. The error status should 'e written to the varia'le cvt<rr. "ou ma& assume all varia'les are alread& declared and initiali?ed.
1DD
:hapter 10 M :haracter $tring 5 Numeric :onversions
1;.3.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the character string to numeric values conversion e*ample program. Update the values of the character strings with different data and verif& that the program produces the correct results. 24 Update the program from the previous @uestion to read a series of character strings from the user, attempt conversion for each character string to a real value. -f invalid, the user should 'e re6prompted. -f valid, the sum of the values should 'e maintained. 8hen the user enters a 0 , the program should stop reading num'ers, displa& the final sum, and terminate. 4 T&pe in the numeric values to character string values conversion e*ample program. Update the values of the real and integer values with different num'ers and verif& that the program produces the correct results. !4 ;evelop a program to read a series of integer values, sum the values, and convert the final sum into a character string. The string should 'e concatenated with the string ,The sum is 2 and displa&ed to the terminal using a single character string varia'le. 14 8rite a program to prompt the user for an integer num'er 'etween 100 and 000, re6prompting until a valid num'er is provided. 8hen a valid num'er is provided, create a file name in the form of ,fileZnum'er[.t*t2, open5create the file, and write all num'ers from 1 to the num'er, one per line, and close the file. /or e*ample, if !2 is entered, the file =i*e42.t+t should 'e created and contain the num'ers 1, 2, , b, !2 3one per line4.
1DA
1DB
<
'ystem 'er)ices
The term s&stem services generall& refers to as(ing the operating s&stem for information. The read, write, and file operations 3open, read, write, close4 are common s&stem services and have alread& 'een addressed in a previous chapter. <ther s&stem services include o'taining the date and5or time from the operating s&stem and o'taining the command line arguments 3if an&4. The term command line arguments is used to refer to information entered on the command line after the program name. This allows the user to provide some information to the program 'efore it starts 3or as the program is started4, which might save time as compared to prompting for and interactivel& reading the information at run6time. 8hile there are man& s&stem services, onl& these 'asic ones are presented for reference. These s&stem services ma& 'e useful when wor(ing on more comple* pro'lems. +dditionall&, the calls and usage for other s&stem services is ver& similar to how these are performed.
<.1
#ate and Time
The date and time functions are com'ined into a single s&stem service call. The date and time values can 'e o'tained as character strings, as integers, or 'oth simultaneousl&. The options for date and time as e*plained in the ne*t section followed '& an e*ample. -t must 'e noted that if the operating s&stem has an incorrect date or time, the values returned to the program will also 'e incorrect.
2<.1.1
Date an' 0ime !ptions
The date and5or time values are are o'tained from the operating s&stem using the get_date_time() s&stem service call. The argument or arguments for the s&stem service call must specif& at least one of the following options#

date U Zcharacter3B4[ time U Zcharacter3104[ one U Zcharacter314[ va*ues U Zinteger values arra&[
+s noted, each option must provide a location of where to place the results of the specified si?e and date t&pe. The options are comma separated, similar to the read and write calls noted in a previous chapter. +t least one argument must 'e included in the call. The ?one, or time ?one, option will provide the time difference 'etween local time and :oordinated
Universal Time 3UT:1 4. The character string will provide a result in hours:minutes format and the integer values will 'e in minutes onl&. However, the minutes can 'e easil& converted to hours.
1 /or more information regarding coordinated universal time, refer to# http#55en.wi(ipedia.org5wi(i5:oordinatedRUniversalRTime
1D0
:hapter 20 K $&stem $ervices The options and associated values returned as more full& descri'ed in the following ta'le. Option date Data 4ype character3B4 Description The string returned will 'e in the form
""""II;;, where """" is &ear, II is month, and ;; is date.
time
character3104
The string returned will 'e in the form HHII$$.$$$ where HH is hour, II is minute, $$ is second, and $$$ is milliseconds. The string returned will 'e in the form of dHHII, where HHII is the time difference 'etween local time and :oordination Universal Time. The values will 'e returned in the B value integer arra& as follows#

one
character314
va*ues
integer arra&, B elements
values314 Q &ear values324 Q month 316124 values3 4 Q date 316 14 values3!4 Q month 316124 values314 Q hour 3062 4 values3D4 Q time ?one difference 3minutes4 values3A4 Q seconds 306104 values3B4 Q milleseconds 3060004
Each argument is optional, 'ut at least one argument must 'e included. Iultiple arguments are allowed.
2<.1.2
Date an' 0ime "#ample Program
The following as an e*ample program that o'tains the date and time information from the operating s&stem in various formats. The final results are shown for reference.
! Example program to obtain the date and time from the system.
program timeDateExample ! ---------! Declarations. implicit none
1A0
:hapter 20 M $&stem $ervices

integer, dimension(8) :: valuesArr character(len=8) :: today character(len=10) :: now character(len=5) :: myzone integer :: i ! ---------! Display simple header. write (*,'(a)') "Example Program for Date and Time Functions." ! ---------! Get date, time, and zone from system as characters. ! Display to screen for reference. call date_and_time(date=today) write (*,'(/a, a)') "Today is: ", today call date_and_time(time=now, zone=myzone) write (*,'(a, a)') "Time is: ", now write (*,'(a, a/)') "Time Zone is: ", myzone ! ---------! Get all date values from the system as integers. ! Display to screen for reference. call date_and_time(values=valuesArr) write (*,'(a)') "Values Array:" write write write write write write write (*,'(a, (*,'(a, (*,'(a, (*,'(a, (*,'(a, (*,'(a, (*,'(a, i4)') i2)') i2)') i2)') i2)') i2)') i3)') "Date, "Date, "Date, "Time, "Time, "Time, "Time, Year: Month: Day: Hour: Minutes: Seconds: Millseconds: ", ", ", ", ", ", ", valuesArr(1) valuesArr(2) valuesArr(3) valuesArr(5) valuesArr(6) valuesArr(7) valuesArr(8) & & &
write (*,'(/,a, i8)') "Time difference with UTC in minutes: ", valuesArr(4)
write (*,'(a, i2, a1, i2.2 ,/)') & "Time difference with UTC in hours: ", & valuesArr(4)/60, ":", mod(valuesArr(4), 60) end program timeDateExample
1A1
:hapter 20 K $&stem $ervices 8hile this program does not reall& use the time or date values for an&thing meaningful, it does provide an e*ample of how the information is o'tained for use in other, more comple* programs. The output of the this e*ample program is shown as follows#
Today is: 20131212 Time is: 154032.491 Time Zone is: -0800 Values Array: Date, Year: Date, Month: Date, Day: Time, Hour: Time, Minutes: Time, Seconds: Time, Millseconds: 2013 12 12 15 40 32 491
Time difference with UTC in minutes: -480 Time difference with UTC in hours: -8:00
The UT: for 9as Fegas, Nevada is indeed, 6B hours as shown. The results for the UT: will 'e 'ased on the actual geographic location of where the s&stem e*ecuting the program is located.
<.
Command Line %rguments
The usage of command line arguments, information entered on the command line after the program name, can 'e ver& useful in specific circumstances. =& allowing the user to provide some information on the command line, it saves the effort of entering the information interactivel& after the program starts. The term command line arguments is sometimes referred to as command line options. /or e*ample, when starting a /ortran program for a simple game, the persons name could 'e provided on the command line. -f the name is provided, the program could use that name. <therwise, the program could use a generic name such as 7pla&er7. The command line might appears as follows#
c:\fortran> tictactoe ed
<n Uni* 'ased s&stems, this might 'e#

% ./tictactoe ed
8here tictactoe is the name if the program and 7ed7 is the single command line argument. Iultiple command line arguments can 'e provided, 'ut must 'e separated with a space or multiple spaces. There is no predefined re@uired format. The formatting or ordering re@uirements are up to the program. The gfortran compiler re@uires command line arguments for the various options include the input file name 3i.e., tictactoe.f014 and the output file name 3i.e., 6o tictactoe4 specification. /or e*ample,
c:\fortran> gfortran tictactoe.f95 -o tictactoe
/or the gfortran compiler, there is no re@uired order for the command line arguments. However, a valid output file name must follow the 76o7 argument. 1A2
:hapter 20 M $&stem $ervices The error handling for command line arguments is t&picall& handled differentl&. Ian& programs chec( the command line arguments, and if incorrect for an& reason, displa& an error message and terminate the program. This is what the gfortran compiler does when invalid or incorrect arguments are provided. -t would 'e possi'le to create a program that could verif& arguments, and if incorrect, displa& an error message and then re@uest correct input from the user. The handling of the command line arguments processing is entirel& the responsi'ilit& of the program and not the operating s&stem.
2<.2.1
4rgument Count
There are generall& two steps to o'taining the command line arguments. The first step is getting the argument count or the num'er of arguments entered on the command line. The previous tic9tac9toe e*ample has one argument 3i.e., 7ed74. The previous gfortran e*ample had three 3i.e., 7tictactoe.f017, 76o7, and 7tictactoe74. The argument count is o'tained using the command_argument_count() s&stem service as follows#
integer :: myCount myCount = command_argument_count()
8hich will return the count in the varia'le my%ount 3as shown a'ove4. The count will 'e ?ero if no arguments are entered.
2<.2.2
>et 4rguments
<nce the argument count is availa'le, the actual arguments can 'e o'tained. The arguments are alwa&s returned as character values. -f the argument is meant to 'e used as a real or integer value, it must 'e converted. The :haracter $tring 5 Numeric :onversions chapter provides a description of how this can 'e accomplished. 8hen o'taining the command line arguments, the get_command_argument() s&stem service is used. +n argument is returned into a specified character varia'le. The character varia'le should 'e large enough 3i.e., a'le to hold enough characters4 to store the e*pected argument. The actual length of the returned argument can optionall& 'e provided. +dditionall&, if the character varia'le is too small, the returned result will 'e truncated and the status set accordingl& to indicate an error. The options and associated values returned are descri'ed in the following ta'le. Option *ength Data 4ype integer Description -nput integer argument indicating which argument should 'e returned. Iust 'e 'etween 1 and the commandLargumentLcountDE value. <utput character varia'le of where to store the Nth argument as specified '& the length value 3a'ove4. The varia'le must 'e declared with an appropriate si?e.
va*ue
character3Y4
1A
:hapter 20 K $&stem $ervices *ength integer <utput integer argument for the actual length of the string returned '& the value argument 3a'ove4. <utput integer argument for the returned status value. + return status value of 0 is success and 61 is fail.
status
integer
The first two arguments are re@uired and the final two arguments are optional.
2<.2.3
Comman' .ine 4rguments8 "#ample Program
This simple e*ample o'tains the command line argument count and displa&s the arguments to the screen for reference. -n this e*ample, the program will e*pect a real value as the first argument and an integer value as the second argument 3if a second argument is provided4. +n& additional arguments, while not used, are still displa&ed the screen along with the argument count value. /or this e*ample, since the num'er of arguments is un(nown ahead of time, an arra& to hold the arguments is allocated at run6time. 8hile this is not necessar&, it does help provide a more complete e*ample. $uch a process would onl& 'e appropriate if a var&ing num'er of command line arguments is desired.
! Example program to demonstrate how to obtain the ! command line arguments from the system. program argsExample implicit none integer :: argCount, allocStatus, rdErr, i, iNum real :: rNum character(len=80), dimension(:), allocatable :: args ! ---------! Get command line argument count from system. argCount = command_argument_count() if (argCount == 0) then write (*,'(a)') "No command line arguments provided." stop end if ! ---------! Allocate an array to hold the arguments. allocate(args(argCount), stat=allocStatus)
1A!

if (allocStatus > 0) then write (*,'(a)') "Allocation error, program terminated." stop end if ! ---------! Get each argument, one at a time, from system. do i = 1, argCount call get_command_argument(number=i,value=args(i)) end do ! ---------! Display arguments to screen. if (argCount == 0) then write (*,'(a)') "No command else if (argCount == 1) then write (*,'(a, i1, a)') argCount, " else write (*,'(a, i2, a)') argCount, " end if line arguments provided." "There was ", & command line argument." "There were ", & command line arguments."
&
write (*,'(/,a)') "The arguments were: " do i = 1, argCount write (*,'(a, a)') " ", trim(args(i)) end do write (*,*) end if ! ---------! Convert a string to a numeric value using an internal read. if (argCount >= 1) then read (args(1), '(f12.5)', iostat=rdErr) rNum if (rdErr == 0 ) then write (*,'(a, f12.5)') & "Argument 1 - Real Number = ", rNum else write (*,'(a)') "Error, invalid real value." end if end if if (argCount >= 2) then
1A1
:hapter 20 K $&stem $ervices

read (args(2), '(i10)', iostat=rdErr) iNum if (rdErr == 0 ) then write (*,'(a, i10)') & "Argument 2 - Integer Number = ", iNum else write (*,'(a)') "Error, invalid integer value." end if end if write (*,*) end program argsExample
+n e*ample of the output for this program with valid command line arguments provided is shown 'elow. The e*ecuta'le name of the e*ample program is 7args7.
c:\fortran> args 3.14 23 hello world There were 4 command line arguments. The arguments were: 3.14 23 hello world Argument 1 - Real Number = Argument 2 - Integer Number = c:\fortran> 3.14000 23
+nother e*ample of the output for this program with invalid command line arguments provided is shown as follows#
c:\fortran> args 3.14 23 hello world There were 4 command line arguments. The arguments were: hello 3.14 23 world Error, invalid real value. Error, invalid integer value. c:\fortran>
*ote, the order for the valid and invalid arguments was chosen ar'itraril&. 1AD
<.!
,xercises
2<.3.1
Quiz Questions
=elow are some @ui? @uestions. 14 :an the date alone 'e o'tained 3i.e., without o'taining the time4 using the getLdateLtimeDE s&stem service 3&es5no4N 24 8hen using the getLdateLtimeDE s&stem service to o'tain the integer date and time values, what is the inde* num'er for the# 1. The month value. 2. The hour value. . The &ear value. 4 How can the integer time ?one value 'e converted to hours:minutes formatN !4 .rovide the getLdateLtimeDE s&stem service call to o'tain the current date string into the alread& declared character varia'le d'tr. 14 .rovide the getLdateLtimeDE s&stem service call to o'tain the current time string and time ?one string into the alread& declared character varia'les time'tr and zone'tr. D4 .rovide the getLdateLtimeDE s&stem service call to o'tain the current date5time integer values, and the current date string into the alread& declared B element integer values&rr arra&. A4 -f there are no arguments entered on the command line, what is returned '& the getLcommandLargumentDE s&stem serviceN B4 .rovide an appropriate statement to o'tain the rd command line argument, the argument length, and a status value. "ou ma& assume the varia'les for the command line argument 3character4, named args, the length 3integer4, named arg3length, and the status 3integer4, named, arg3stat are alread& declared appropriatel&.
2<.3.2
uggeste' Pro(ects
=elow are some suggested proEects. 14 T&pe in the get date and time e*ample program. Update the output to more clearl& displa& onl& the current date and time on one line. )emoval the unnecessar& or redundant output. 24 T&pe in the get command line arguments e*ample program. E*ecute the program using a variet& of different e*pected and une*pected arguments.
1AA
:hapter 20 K $&stem $ervices 4 ;evelop a program that e*pects command line arguments for a title and time 3hours and minutes4. :alculate and displa& the difference 'etween the current time and the time from the command line. -f the command line arguments are incomplete or incorrect, an error message should 'e displa&ed and the program, terminated. The program should use 2!6hour format. <ne possi'le approach to determining the time difference would 'e to convert each time into minutes 3from hours and minutes format4, compute the difference, and convert the difference in minutes 'ac( to hours and minutes format. The final output should displa& the title, the s&stem time, the entered time, and the time difference. +ll times should 'e displa&ed in hours:minutes format. !4 8rite a program to get the date from the s&stem and displa& a formatted date. The formatted date should 'e# Zda& of wee([, Zmonth name[ Zdate[, Z&ear[. /or e*ample, 12525201 should 'e displa&ed as 2onday, Decem3er 2, 201!. Each string should include onl& the appropriate spacing. $pecificall&, there should 'e no e*tra spaces 'etween the words or num'ers 3including the date value, 2 in the e*ample4. To calculate the da& on which a particular date falls, the following algorithm ma& 'e used. *ote, all varia'les are integers and the divisions are integer divisions. a = 14 month 12
y = year a m = month + 12 a 2 daynum =
date + y +
y y y m + + !1 4 100 400 12
mod $
8here the month, date, and year varia'les are the integer date values 312, 2, and 201 in the previous e*ample4. The final value of daynum is 0 for a $unda&, 1 for a Ionda&, 2 for a Tuesda&, and so forth with the ma*imum value of D for $aturda&. 14 Update the program from the previous @uestion to write the formatted date to a file. The file name should 'e created 'ased on the current date in the following format ,fileZII;;""[.t*t2 /or e*ample, for a date of 125025201 , the file should 'e named =i*e12021!.t+t and contain the character string 2onday, Decem3er 2, 201!. D4 8rite a program to o'tain the current date and attempt to open a file 'ased on the date in the following format, ,fileZII;;""[.t*t2. /or e*ample, for a date of 125025201 , the file should 'e named =i*e12021!.t+t. -f the file e*ists, the contents should 'e displa&ed to the screen. -f the file does not e*ist, an appropriate error message should 'e displa&ed.
1AB
%""endix % 1 %'CII Table
This ta'le lists the +merican $tandard :ode for -nformation -nterchange 3+$:--4 characters or s&m'ols and their decimal num'ers.
Char.
J O P Q R S T D E B A , 9 . 0 0 1 2 ! 4 ' , $ . & W X G @ F a
Dec.
!2 !! !4 !' !, !$ !. !& 40 41 42 4! 44 4' 4, 4$ 4. 4& '0 '1 '2 '! '4 '' ', '$ '. '& ,0 ,1 ,2 ,!
Char.
M 1 ) C D E % " C I J < / 2 6 O ; 5 # 4 : V 7 K V I Y [ ] _ L
Dec.
,4 ,' ,, ,$ ,. ,& $0 $1 $2 $! $4 $' $, $$ $. $& .0 .1 .2 .! .4 .' ., .$ .. .& &0 &1 &2 &! &4 &'
Char.
N a 3 c d e = g h i U ? * m n o p H r s t u v 8 + y Z \ ^ `
Dec.
&, &$ &. && 100 101 102 10! 104 10' 10, 10$ 10. 10& 110 111 112 11! 114 11' 11, 11$ 11. 11& 120 121 122 12! 124 12' 12, 12$
1A0
:hapter 21 K +ppendi* + C +$:-- Ta'le
1B0
%""endix 2 1 Windo*s 'tart=7" Instructions

The following provides some specific instructions for getting started. These instructions are specificall& geared for using a 8indows 'ased .:s. This includes all versions of 8indows from 8indows J., 8indows Fista, 8indows A, and 8indows B. The 'asic process is ver& similar to I+: and 9inu* 3which is not covered here4.
.1
Wor/ing Files
=efore wor(ing with /ortran program files, &ou should decide where &ou will 'e wor(ing 3:e# drive, U$= drive, networ( drive, etc.4 and create a wor(ing director& where &our files will 'e placed. -n general, it will 'e easier if &our /ortran files are not mi*ed with other, unrelated files. This director& should 'e someplace &ou can easil& get to it. That might 'e on &our home wor(station5laptop, on a networ( drive, or on a U$= drive.
&btaining The Com"iler
/irst, &ou will need to download and install the GNU /ortran compiler. The main we' page for the GNU /ortran compiler is#
http://gcc.gnu.org/fortran/
This page provides general information regarding the /ortran compiler development effort, proEect o'Eectives, and current status. Iore specific information, and the 8indows compiler 'inaries, can 'e found on the g/ortran 8i(i page, which is located at#
http://gcc.gnu.org/wiki/GFortran
This page contains lin(s to the Gfortran 'inaries. <n this page, clic( on the lin( la'eled# )inaries =or 7indo8s, /inu+, and 2acO# 8hich will displa& the page for the GNU=inaries for various platforms, including 8indows, Iac<$, and 9inu*. :lic( on the 8indows lin(, which will show the various 8indows options. /or standard 8indows 3J.5Fista5A5B4, the heading 2in"7 3ui*d 3,native 8indows2 'uild4, includes a lin( for the latest installer. :lic( on the lin( and download the 8indows installation program. "ou will need to access this file to perform the actual installation. This version will wor( on all supported 8indows versions including 8indows Fista, 8indows J., 8indows A and 8indows B. +fter downloading, install the compiler. The installation can 'e accomplished '& dou'le6clic(ing on the downloaded file. +s with all 8indows installs, it will re@uire $&stem +dministrator privileges.
1B1
:hapter 22 K +ppendi* = C 8indows $tart6Up -nstructions
.!
Command Prom"t
-n order to compile and wor( with programs under 8indows, we will need to provide t&ped commands to the computer. This is done from within the ,:ommand .rompt2 utilit&.
22.3.1
?in'o+s @P:)ista:2
-n /or 8indows A, the ,:ommand .rompt2 is usuall& under -rograms Q 1ccessories Q Command -rompt.
22.3.2
?in'o+s 7
/or 8indows B, the ,:ommand .rompt2 can 'e found '& using $earch and is listed under the 7indo8s #ystem heading.
22.3.3
Comman' Prompt ?in'o+
The open :ommand .rompt window for an& 8indows version will loo( similar to the following#
<nce the :ommand .rompt is open, the device and director& for the wor(ing files can 'e set.
22.3.4
De6ice an' Directory
-n order to compile and wor( with programs under 8indows, a wor(ing director& should 'e esta'lished. This is where the program files will 'e stored. /irst, esta'lish the device of the wor(ing director&. -f the files are on :#e 3the main hard drive4, the device is alread& set. -f the wor(ing director& is located on a networ( drive, alternate drive, or U$= drive, the device will need to 'e set. Using the ,I& :omputer2, determine the device or drive letter where &ou director& is located. T&pe that letter at the prompt in the :ommand .rompt window. /or e*ample, if &our device is <, &ou would t&pe ,?W2. +t the ,G#e[2 &ou will need to change director& into the director& where &our files are 3if &ou created one4. The ,cd ZdirRname[2 command can 'e used. /or e*ample, if the director& is named cs11A, the command would 'e ,cd cs11$2.
1B2
:hapter 22 M +ppendi* = C 8indows $tart6Up -nstructions /or e*ample#

C:\Documents and Settings\Ed\My Documents> k: K:\> cd cs117
+t this point, t&ping dir 3for director&4 will provide a list of files in the director&. 8hile the format will appear different, the files are the same as shown in the 2y Computer listing.
.$
Com"iler Installation 3erification
To ensure the compiler is installed correctl&, open the ,:ommand .rompt2, and t&pe g=ortran at the prompt.
K:\cs117> gfortran gfortran: no input files
The ,no input files2 message means that the installation was completed correctl&. -t is not necessar& to set the device or director& in order to perform this verification. However, if the following message is displa&ed,
K:\cs117> gfortran 'gfortran' is not recognized as an internal or external command, operable program or batch file.
means that the /ortran compiler is not installed. The installation issue must 'e addressed 'efore continuing. <nce the installation is completed successfull&, the compilation steps detailed in :hapter can 'e completed.
.5
Com"ilation
<nce the /ortran compiler is installed, programs can 'e compiled. <pen the ,:ommand .rompt2, and set the device and director& as appropriate. +t this point the program can 'e compiled, using ,gfortran. The optional ,6o2 @ualifier is used to set the name of the output file. To e*ecute, &ou can t&pe the name of the e*ecuta'le 3that was specified with the ,6o24. To compile the e*ample program, the following command would 'e entered#
K:\cs117> gfortran -o hw hw.f95
This command will tell the 7gfortran7 compiler to read the file hw.f95 and, if there are no errors, create an e*ecuta'le file named hw.exe. -f there is an error, the compiler will generate an error message, sometimes cr&ptic, and provide a line num'er. $uch errors are usuall& the result of mist&ping one of the instructions. +n& errors must 'e resolve 'efore continuing.
.0
,xecuting
To e*ecute or run a program, t&pe the name of the e*ecuta'le file. /or e*ample, to e*ecute or run the 1B
:hapter 22 K +ppendi* = C 8indows $tart6Up -nstructions hw.exe program#

K:\cs117> hw Hello World K:\cs117>
8hich will e*ecute the e*ample program and displa& the ,Hello 8orld2 message to the screen.
.5
,xam"le
+ more complete e*ample is as follows#
-t is not necessar& to t&pe the e*tension 3i.e., ,.e*e24 portion of the file name.
1B!
%""endix C 1 +andom >umber -eneration
Generating random num'ers is a common re@uirement for man& pro'lems. The following provides a summar& of utili?ing the 'uilt6in /ortran random num'er generator routines.
!.1
Initiali(ation
The first step in generating random num'ers is to initiali?e the /ortran random num'er generator, randomRseed34. The most 'asic initiali?ation is performed as follows#
call random_seed()
This will initiali?e the random num'er generator with a default seed. +s such, each e*ecution will re6 generate the same series of random num'ers for each e*ecution. 8hile this ma& not appear ver& random, since successive e*ecutions generate the same series of random num'ers, the testing is more repeata'le.
!.
-enerating +andom >umber
To re@uest a random num'er, a real varia'le must 'e declared and then passed to the following call to the 'uilt6in randomRnum'er34 routine. /or e*ample#
call random_number(x)
The random num'er 'etween 0.0 and 1.0 such that 0.0 _ random num'er Z 1.0. -n order to o'tain a larger num'er, it can 'e multiplied '& an appropriate scale. /or e*ample, to simulating the roll of a dice, a random integer num'er 'etween 1 and D would 'e re@uired. The following code would o'tain the random num'er and then scale it and convert to integer as re@uired.
call random_number(x) die = int(x*6.0) + 1
$ince the 0.0 is a possi'le value and 1.0 is not 3 0.0 _ random num'er Z 1.04 1 is added to ensure that 0 can not 'e assigned to the varia'le die. /urther, since .000 is the largest possi'le value 3since 1.0 is not4, and .000 Y D will generate D 31.0 truncated to 1 with 1 added4.
1B1
:hapter 2
K +ppendi* : C )andom Num'er Generation
!.!
,xam"le
+ simple e*ample program to generate 1000 random integer num'ers, each 'etween 1 and 100, is as follows#
program rand implicit none integer, parameter :: rcount=1000 integer :: i integer, dimension(rcount) :: nums real :: x call random_seed() do i = 1, rcount call random_number(x) nums(i) = int(x*100.0) + 1 end do write (*,'(a)') "Random Numbers:" do i = 1, rcount write (*,'(i3,2x)', advance="no") nums(i) if (mod(i,10)==0) write(*,*) end do end program rand
The call to randomRseed34 must 'e performed 'efore the call to randomRnum'er34. +dditionall&, the call to randomRseed34 can onl& 'e performed once. The output of this e*ample program is shown 'elow#
Random Numbers: 100 57 97 22 14 91 86 41 21 61 72 90 66 56 98 77 34 12 56 100 100 82 56 7 67 67 51 63 78 96
75 39 97 66 91 62 75 49 27 12
37 45 60 16 66 83 96 60 8 32
49 67 68 62 73 95 10 14 11 60
8 2 46 98 41 74 74 59 55 5
1 66 34 100 93 50 76 52 38 12
35 65 11 26 15 38 95 89 2 22
35 33 76 56 68 43 71 31 80 11
Each e*ecution will generate the same series of random num'ers.
1BD
:hapter 2
M +ppendi* : C )andom Num'er Generation
!.$
,xam"le
-n order to generate different random num'er for successive e*ecutions, the seed must 'e initiali?ed with a different set of seed values each time. The following e*ample simulates the roll of two dice, which re@uires two random integer num'ers, each 'etween 1 and D.
program diceRoll implicit none integer :: m, die1, die2, pair real :: x integer :: i, n, clock integer, dimension(:), allocatable :: seed character(10) :: nickname call random_seed(size = n) allocate(seed(n)) call system_clock(count=clock) seed = clock + 37 * (/(i-1, i=1, n)/) call random_seed(put = seed) deallocate(seed) call random_number(x) die1 = int(x*6.0) + 1 call random_number(x) die2 = int(x*6.0) + 1 write (*,'(2(a,1x,i1/),a,1x,i2)') "Dice 1:", die1, "Dice 2:", die2, "Dice Sum", (die1+die2) end program diceRoll &
8ill generate different values each e*ecution. /or e*ample, three e*ecutions of the e*ample program are shown 'elow#
C:\fortran> dice Dice 1: 5 Dice 2: 4 Dice Sum 9 C:\fortran> dice Dice 1: 2 Dice 2: 4 Dice Sum 6
1BA
:hapter 2
K +ppendi* : C )andom Num'er Generation
C:\fortran> dice Dice 1: 1 Dice 2: 6 Dice Sum 7 C:\fortran>
The dice values will 'e different for each e*ecution.
1BB
%""endix # 1 Intrinsic Functions
The following is a partial listing of the /ortran 01 intrinsic functions. <nl& the most common intrinsic functions are included in this section. + complete list can 'e found on6line at the GNU /ortran documentation we' page.
$.1
Con)ersion Functions
The following ta'le provides a list of intrinsic functions that can 'e used for conversion 'etween different data t&pes.
%unction -NT3+4 N-NT3J4 )E+93+4 Description )eturns integer value of real argument +, truncating 3real part4 towards ?ero. )eturn nearest integer value 3with appropriate rounding up or down4 of the real argument J. )eturns the real value of integer argument +.
$.
Integer Functions
The following ta'le provides a list of intrinsic functions that can 'e used for integers.
%unction +=$3+4 I<;3)1,)24 Description )eturns integer a'solute value of integer argument +. )eturn the integer remainder of integer argument )1 divided '& integer argument )2.
1B0
:hapter 2! K +ppendi* ; C -ntrinsic /unctions
$.!
+eal Functions
The following ta'le provides a list of intrinsic functions that can 'e used for reals.
%unction +=$3+4 +:<$384 +$-N384 +T+N3J4 :<$384 9<G384 I<;3)1,)24 $-N384 $>)T384 T+N3J4 Description )eturns real a'solute value of real argument +. )eturns real inverse cosine of real argument 8 in radians. )eturns real inverse sine of real argument 8 in radians. )eturns real inverse tangent of real argument J in radians. )eturns real cosine of real argument 8 in radians. )eturns real natural logarithm of real argument 8. )eal argument 8 must 'e positive. )eturn the real remainder of real argument )1 divided '& real argument )2. )eturns real sine of real argument 8 in radians. )eturns real s@uare root of real argument 8. )eal argument 8 must 'e positive. )eturns real tangent of real argument J in radians.
$.$
Character Functions
The following ta'le provides a list of intrinsic functions that can 'e used for characters5strings.
%unction +:H+)3-4 Description )eturns the character represented '& integer argument 'ased on the +$:-- ta'le 3+ppendi* +4. -nteger argument must 'e 'etween 1 and 12A. )eturns the integer value of the character argument : represented '& +$:-- ta'le 3+ppendi* +4. )eturns an integer value representing the length of string argument $T). )eturns an integer value representing the length of string argument $T) e*cluding an& trailing spaces. )eturns logical true, if $T)1 f $T)2 and false otherwise. )eturns logical true, if $T)1 [ $T)2 and false otherwise. )eturns logical true, if $T)1 _ $T)2 and false otherwise. )eturns logical true, if $T)1 [ $T)2 and false otherwise. )eturns string 'ased on the string argument $T) with an& trailing spaces removed.
-+:H+)3:4 9EN3$T)4 9ENRT)-I3$T)4 9GE3$T)1,$T)24 9GT3$T)1,$T)24 99E3$T)1,$T)24 99T3$T)1,$T)24 T)-I3$T)4
100
:hapter 2! M +ppendi* ; C -ntrinsic /unctions
$.5
Com"lex Functions
The following ta'le provides a list of intrinsic functions that can 'e used for comple* num'ers.
%unction +-I+G3W4 :I.9J3J,"4 )E+93+4 Description )eturns the real value of the imaginar& part of the comple* argument W. )eturns comple* value with real argument J and the real part and real argument " as the imaginar& part. )eturns the real value of the real part of the comple* argument W.
$.0
%rray Functions
The following ta'le provides a list of intrinsic functions that can 'e used for arra&s.
%unction I+J9<:3+14 I+JF+93+14 I-N9<:3+14 I-NF+93+14 $UI3+14 Description )eturns integer location or inde* of the ma*imum value in arra& +1. )eturns ma*imum value in arra& +1. T&pe of value returned is 'ased on the t&pe of the argument arra& +1. )eturns integer location or inde* of the minimum value in arra& +1. )eturns minimum value in arra& +1. T&pe of value returned is 'ased on the t&pe of the argument arra& +1. )eturns sum of values in arra& +1. T&pe of value returned is 'ased on the t&pe of the argument arra& +1.
101
:hapter 2! K +ppendi* ; C -ntrinsic /unctions
$.5
'ystem Information Functions
The following ta'le provides a list of intrinsic functions that o'tain information from the s&stem.
%unction Description
:<II+N;R+)GUIEN )eturns the num'er of command line arguments. TR:<UNT34 GETR:<II+N;R+)G UINENT3NUI=E), F+9UE, 9ENGTH, $T+TU$4 )eturns command line arguments, if an&. NUI=E), integer argument of the num'er to return. Iust 'e 'etween 1 and :<II+N;R+)GUIENTR:<UNT34. F+9UE, character3Y4, Nth argument 9ENGTH, integer, length of argument returned in F+9UE $T+TU$, integer, status, 0Usuccess and 61UF+9UE character arra& is too small for argument, other valuesUretrieval failed )eturns the amount of :.U time e*pended on the current program in seconds. T-IE is return as a real value. )eturn date and time. ;+TE34, character3B4, string in the form """"II;;, where """" is &ear, II is month, and ;; is date. T-IE34, character3104, string in the form HHII$$.$$$ where HH is hour, II is minute, $$ is second, and $$$ is millisecond. W<NE34, character314, string in the form of dHHII, where HHII is the time difference 'etween local time and :oordination Universal Time. F+9UE$34, integer arra& where F+9UE$314 Q &ear F+9UE$324 Q month 316124 F+9UE$3 4 Q date 316 14 F+9UE$3!4 Q month 316124 F+9UE$314 Q hour 3062 4 F+9UE$3D4 Q Time ?one difference 3minutes4 F+9UE$3A4 Q seconds 306104 F+9UE$3B4 Q milleseconds 3060004 Each argument is optional, 'ut at least one argument must 'e included.
:.URT-IE3T-IE4 ;+TER+N;RT-IE 3;+TE, T-IE,W<NE,F+9UE$4
102
%""endix , 1 3isuali(ation *ith ->7"lot
The /ortran language does not have an& 'uilt6in graphics capa'ilities. To support some 'asic data visuali?ation a plotting application, GNUplot, can 'e used. GNUplot is a free, open source plotting program that can plot data files and displa& user6defined functions. This appendi* provides a ver& 'rief summar& of some of the 'asic GNUplot functions as applied to plotting data from simple programs in this te*t. +n general e*ample program to plot a simple function is provided for reference.
5.1
&btaining ->7"lot
The first step is to o'tain and install GNUplot. GNUplot is availa'le at,
http://www.gnuplot.info/
To ensure that GNUplot is installed correctl&, for 8indows machine, &ou can enter command prompt and t&pe,
wgnuplot
which will start GNUplot '& opening a new window. To e*it, t&pe e+it at the prompt. :omplete documentation, tutorials, and e*amples are availa'le at that site. +dditionall&, there are man& other we' site dedicated to GNUplot.
5.
Formatting Plot Files
$ince our specific use of GNUplot will involve plotting a data file created with a /ortran program, it will 'e necessar& to provide some information and directions for GNUplot in the file. That information is provided in a header 3first few lines4 and a footer 3last few lines4. +s such, the program must first write the header, write the data, t&picall& in the form of data points to 'e plotted, and write a final footer. The header and footer ma& 'e ver& different 'ased on what is 'eing plotted.
10
:hapter 21 K +ppendi* E C Fisuali?ation with GNUplot
2-.2.1
/ea'er
The header will provides some guidelines on how the output should loo(, including title 3if an&4, a*ises 3if an&4, la'les 3if an&4, and plotting color3s4. +dditionall&, comments can 'e included with a ,a2 character. :omments are useful to provide information a'out the contents of the plot file or nature of the data 'eing plotted. + t&pical header might 'e as follows#
# Example Plot File set title "CS 117 Plot Function" plot "-" notitle with dots linewidth 2 linecolor 2
<nce the header is written, a series of data points can 'e written.
2-.2.2
%ooter
The footer is used to formall& tell GNUplot there are no more points. +dditionall&, the ,pause2 directive can 'e used to ensure that an& plots displa&ed from the command line are left on the screen. + t&pical footer might 'e as follows#
end pause -1
Nothing after the footer will 'e read '& GNUplot.
5.!
Plotting Files
wgnuplot file.plt
-n order to displa& a plot file on a 8indows machine, at the command prompt, t&pe,
which will start GNUplot and instruct GNUplot to read the file ,file.plt2. The file name can 'e an&thing and the file e*tension is not re@uired to 'e ,.plt2. -f the header or footer commands are incorrect or the data points are invalid, nothing will 'e displa&ed. To investigate, the file can 'e opened with a te*t editor.
5.$
,xam"le
This section provides an e*ample program that plots a simple function. y = sin ( x )
1 cos ( x ) !.0
The program, data file, and final output are presented for reference.
10!
:hapter 21 M +ppendi* E C Fisuali?ation with GNUplot
2-.4.1
Plot Program
The following is an e*ample program that generates points, opens a plot file, write the header, data points, and footer.
program plotExample implicit none real, dimension(200) :: x, y integer :: i, opnstat ! Generate x and y points do i = 1, 200 x(i) = i * 0.05 y(i) = sin(x(i)) * (1-cos(x(i)/3.0)) end do ! Output data to a file open (12, file="data.plt", status="replace", action="write", position="rewind", & iostat=opnstat) if (opnstat > 0) stop "error opening plot file." &
! Write header write (12, '(a)') "# Example Plot File" write (12, '(a)') "set title ""Example Plot Function"" " write (12,'(a,a)') "plot ""-"" notitle with dots ", "linewidth 2 linecolor 2" ! Write points to file. do i=1,100 write(12,*) x(i), y(i) end do ! Write footer and close file write (12, '(a)') "end" write (12, '(a)') "pause -1" close(12) end program plotExample
The data file name can 'e changed or read from the user.
101
:hapter 21 K +ppendi* E C Fisuali?ation with GNUplot
2-.4.2
Plot %ile
The output file this program appears as follows#

# Example Plot File set title "Example Plot Function" plot "-" notitle with dots linewidth 2 linecolor 2 5.0000001E-02 6.9413913E-06 0.1000000 5.5457884E-05 0.1500000 1.8675877E-04 0.2000000 4.4132397E-04 0.2500000 8.5854460E-04
gman% points not displa%ed due to space considerationsh

4.900000 4.950000 5.000000 end pause -1 -1.043852 -1.048801 -1.050716
The output file can 'e edited with a standard te*t editor. This will allow chec(ing the data file for possi'le errors if it does not displa& correctl&.
2-.4.3
Plot !utput
The plot output is as follows#
<n 8indows machines, the plot can 'e printed '& right clic(ing on the 'lue 'ar 3on top4. This will displa& a menu, with ,.rint2 as one of the options.
10D
0
0.1
%""endix F 1 ?ui( ?uestion %ns*ers

?ui( ?uestion %ns*ers4 Cha"ter 1
This appendi* provides answers for the @ui? @uestions in each chapter.
There are no @ui? @uestions in :hapter 1.
0.
?ui( ?uestion %ns*ers4 Cha"ter
>ui? @uestion answers for chapter 2 are as follows# 14 -n the computer, information is represented in 'inar&. 24 :onvert the /ortran program into 'inar& or machine language. 4 The =U$ connects the memor& to the :.U. !4 The answer are as follows# a4 The 'inar& value 00001012 is 1 in decimal. '4 The 'inar& value 00010012 is 0 in decimal. c4 The 'inar& value 00011012 is 1 in decimal. d4 The 'inar& value 00101012 is 21 in decimal. 14 :haracters are represented in 'inar& using 'inar& +$:--. )efer to +ppendi* + for the +$:-ta'le. D4 .rograms are stored on the the primar& storage device 3$$;, dis( drive, or other storage media4. A4 .rogram must 'e in )+I in order to e*ecute.
0.!
?ui( ?uestion %ns*ers4 Cha"ter !

are as follows#
>ui? @uestion answers for chapter
14 The input file for the compiler is the /ortran program file. 24 The output from the compiler is the e*ecuta'le program. 4 /ortran programs must start with the program GnameF statement and end with the end program GnameF statement. !4 :omments are mar(ed with the e*planation point 3J4. 14 The t&pical file e*tension for a /ortran 00501 program is ,.=&'2. D4 The t&pical file e*tension of the compiler output file is ,.e+e2 for 8indows and no e*tension for Uni* 'ased machines 3i.e., I+: and U'untu4. 10A
:hapter 2D K +ppendi* / C >ui? >uestion +nswers
0.$
?ui( ?uestion %ns*ers4 Cha"ter $
>ui? @uestion answers for chapter ! are as follows# 14 The five /ortran data t&pes are integer, rea*, character, *ogica*, and comp*e+. 24 + /ortran varia'le name must start with a letter. Faria'le names ma& include num'ers, 'ut must start with a letter. 4 The implied data t&pes are integer, real, integer, real, and real. !4 The statements are#
integer :: value real :: count
14 The statements are#

real :: rate = 7.5
D4 The statements are#

real, parameter :: e = 2.71828183
0.5
>ui? @uestion answers for chapter 1 are as follows# 14 The assignment operator is @ 3e@ual sign4. 24 The e*ponentiation operator is BB 3dou'le asteris(s, no space4. 4 +n integer varia'le can 'e converted to a real with the real conversion function. /or e*ample,
realVar = real(intVar)
!4 +n integer varia'le can 'e converted to a real with the real conversion function. /or e*ample,
intVar = int(realVar)
*ote, in this e*ample precision ma& 'e lost since the fractional part is truncated 3not rounded4. 14 The two logical constants are .true. and .=a*se. which must include the leading and trailing periods. D4 $ome intrinsic functions are rea*DE, intDE, nintDE, cosDE, sinDE, modDE, tanDE, and sHrtDE. There are more as listed in +ppendi* ;. A4 The statements are as follows#
x1 = (pi / 6.0) * (3.0 * a**2 + 3.0 * b**2 + c**2) x2 = -(2.0 * a / c) * cos(b) * sin(b) x3 = -b + sqrt(b**2 4.0 * a * c) / (2.0 * a)
10B
:hapter 2D M +ppendi* / C >ui? >uestion +nswers
0.0
>ui? @uestion answers for chapter D are as follows# 14 The ,(*,*)2 means to send it to the screen in 7free format7. 24 The statement is as follows#
write (*,*) "Programming is Fun!"
4 The statements are as follows#

integer :: myage write (*,*) "Enter Age:" read (*,*) myrage
0.5
>ui? @uestion answers for chapter A are as follows# 14 The four program development steps are 1. Understand the .ro'lem 2. :reate the +lgorithm . ;evelop the .rogram !. Test5;e'ug the .rogram 24 The three t&pes of errors are compiler error, run6time error, and logic error. 4 $ince the formula is incorrect, that would 'e a logic error. !4 + compiler error is generated when the compiler does not understand the statement. This often occurs when statements are mis6spelled. /or e*ample,
writte(*,*) "Opps"
would generate a compiler error since 8rite is mis6spelled.
0.9
>ui? @uestion answers for chapter B are as follows# 14 The si* relational operators are F, F@, G, G@, @@, and 0@. 24 The three 'asic logical operators are .and., .or., and .not. where the leading and trailing periods are re@uired. 4 The answers are .true., .true., .=a*se., .true., .true., .=a*se., and .true. where the leading and trailing periods are re@uired.
100
:hapter 2D K +ppendi* / C >ui? >uestion +nswers !4 The statements are as follows#

if (lives <= 0) then write (*,*) "Game Over" end if
*ote, this also could 'e done as follows#

if (lives <= 0) write (*,*) "Game Over"
14 The statements are as follows#

if (num < 0) then num = abs(num) write (*,*) "Nnum was made positive" end if
D4 The statements are as follows#

if (y /= 0) then z = x / y else z = 0 write (*,*) "Z not calculated" end if
*ote, another correct solution is as follows#

if (y == 0) then z = 0 write (*,*) "Z not calculated" else z = x / y end if
A4 The statements are as follows#

if (x <= 0.0) then f = x**2 * y else f = x * y end if
0.9
>ui? @uestion answers for chapter 0 are as follows# 14 8hen an exit statement is e*ecuted, the current loop will 'e e*ited, thus not completing an& remaining iterations. 24 There ma& 'e an unlimited num'er of e*it statements. T&picall&, there is onl& one.
200
:hapter 2D M +ppendi* / C >ui? >uestion +nswers 4 8hen a continue statement is e*ecuted, the remaining statements in the loop are s(ipped and the ne*t iteration of the loop is started 3from the 'eginning of the loop4. !4 There ma& 'e an unlimited num'er of continue statements. T&picall&, there is onl& one. 14 -f there are multiple continue statements, onl& the first e*ecuted continue statement will 'e e*ecuted. D4 The output is as follows#
The SUM is: 15
A4 The output is as follows#

start 1 * 1 * 2 * 2 * 3 * 3 * end 1 2 1 2 1 2 = = = = = = 1 2 2 4 3 6
B4 The statements are valid, however since the initial value of i is greater than the stop value, no statements in the loop will 'e e*ecuted. 04 The statements are valid, however since the initial value of i is greater than the stop value, no statements in the loop will 'e e*ecuted. 104 There is no specified limit. 114 8hen nesting -/ statements, the nested -/ statement must 'e completel& nested within the loop.
0.1<
?ui( ?uestion %ns*ers4 Cha"ter 1<
>ui? @uestion answers for chapter 10 are as follows# 14 The format specifiers are rIw, r%w.d, r/w, nK, 0, and r1. 24 The output, using an ,R2 3underscore4 for 'lan(s, is as follows#
Hello Hello World
4 The output, using an ,R2 3underscore4 for 'lan(s, is as follows#

005
!4 The statement is as follows#

write (*,'(i3)') num1
201
:hapter 2D K +ppendi* / C >ui? >uestion +nswers 14 The statement is as follows#

write (*,'(f7.5)') pi
D4 The statement is as follows#

write (*,'(a,/,a)') "Programming", "Is Fun!"
A4 The statement is as follows#

write (*,'(a)', advance="no") "Enter Number:"
0.11
>ui? @uestion answers for chapter 11 are as follows# 14 The declaration is as follows#
character (len=12) :: msg = "Hello World!"
24 The results are .=a*se., .true., .=a*se., .=a*se., .=a*se., .=a*se., .true. where the leading and trailing periods are re@uired. 4 The value for astr1 U ,a'c2, the value for astr2 U ,!1D2, the value for astr U ,12 !1DAB0102, and the value for astr! U ,;E/12 'c2. !4 The integer value can 'e o'tained '& using the -+:H+)34 function. 14 The character can 'e o'tained from the integer value '& using the +:H+)34 function.
0.1
>ui? @uestion answers for chapter 12 are as follows# 14 =efore a file can 'e read or written, it must 'e opened. 24 The recommended range for a file unit num'er is 'etween 10 and 00 3inclusive4. 4 The answers as as follows# a4 The name of the file is =i*e.t+t. '4 The unit num'er used is 14. c4 "es, the error message will 'e printed if the file does not e*ist. d4 -f the status varia'le, opnstat, is [ 0, an error on the file open has occurred. !4 The read statement is as follows#
read(20,'(13x,i2,8x,i3,8x,i5)') num1, num2, num3
202
0.1!
?ui( ?uestion %ns*ers4 Cha"ter 1!
>ui? @uestion answers for chapter 1 are as follows# 14 +n arra& is considered a direct access structure since an& arra& value can 'e directl& accessed 3without accessing an& other locations4. 24 "es, an arra& can hold integer values. 4 "es, arra& can hold real values. !4 The declarations are as follows#
integer, parameter :: SIZE1 = 100 real, dimension(10) :: rvalues integer, dimension(SIZE1) :: inums real, dimension(0:9) :: counts
14 The answers as as follows# a4 10. '4 21. c4 20. d4 20. D4 +n arra& can 'e allocated a compile6time or run6time 3'ut not 'oth4. A4 The answers as as follows# a4 The arra& will contain the following values# nums 1 2 ! 1 1 00 00 0
'4 The statements is called an implied do loop. c4 The statement will displa& the first 1 values on one line as follows#
__1_99__3_99__0
20
0.1$
?ui( ?uestion %ns*ers4 Cha"ter 1$
>ui? @uestion answers for chapter 1! are as follows# 14 No, a multi6dimensional arra& can hold either real values or integers values. 24 The answer is a. 4 The answers are as follows# a4 11. '4 The arra& contains the following values# 1 1 2 ! 1 c4 .0. d4 !.0 e4 A.0 !4 +n unsuccessful allocation can 'e detected '& chec(ing the status varia'le for a value [ 0. 2.0 .0 !.0 1.0 D.0 2 .0 !.0 1.0 D.0 A.0 !.0 1.0 D.0 A.0 B.0
0.15
>ui? @uestion answers for chapter 11 are as follows# 14 The two t&pes of /ortran su'programs are su'routines and functions. 24 + function returns a single value. 4 The varia'les in the call are referred to as actual arguments. !4 The varia'les in the function heading are referred to formal arguments. 14 The return t&pe is integer. D4 "es, it possi'le to pass integer arguments to a real function. A4 The (e&word contains. B4 The answers are as follows# a4 B. '4 0.
20!
:hapter 2D M +ppendi* / C >ui? >uestion +nswers 04 The answers are as follows# a4 "es. '4 No. c4 10.0. 104 The term 'ariable scope refers to where a given varia'le can 'e accessed. 114 The answers are as follows# a4 in '4 out c4 inout 124 The term side6effect is when a function changes one or more of its input arguments. -n general, this is consider poor practice and should 'e avoided.
0.10
>ui? @uestion answers for chapter 1D are as follows# 14 +n item in a derived data t&pe is referred to as a component. 24 :omponents in a derived data t&pe are accessed with the R. 4 The definition is as follows#
type circle character(20) :: name real :: radius integer :: x, y, x end type circle
!4 The declaration is as follows#

type(circle) :: ring1, ring2
14 The definition is as follows#

type planet character(15) :: name real :: radius, volume end type planet type(planet) :: earth, mars
201
:hapter 2D K +ppendi* / C >ui? >uestion +nswers D4 The definition is as follows#

type date character(10) :: monthname integer :: month, date, year end type date
A4 The answers are as follows# a4 The statements are as follows#

type(date) :: today today%monthname = "December" today%month = 12 today%date = 25 today%year = 2013
'4 The statements are as follows#

type(date) :: newyear newyear%monthname = "January" newyear%month = 1 newyear%date = 1 newyear%year = 2011
0.15
>ui? @uestion answers for chapter 1A are as follows# 14 The primar& purpose for using a module is to allow the program to 'e split into multiple source files. 24 The use Gmodu*e6ameF statement must 'e used in the main program. 4 The modu*e Gmodu*e6ameF statement must 'e used in the main program. !4 <nl& one main program is allowed. 14 +n unlimited num'er of modules is allowed. D4 "es, the contains statement is re@uired in the module.
0.19
>ui? @uestion answers for chapter 1B are as follows# 14 The two re@uirements for a recursive definition are a 'ase case and rule, or set of rules, that reduce toward the 'ase case.
24 -n recursion, the case for which a solution is o'tained directl& is called the 'ase case.
20D

4 The (e&word recursive is re@uired for a recursive su'routine. !4 The two (e&words re@uired for a recursive function are recursive and resu*t. 14 There are no special re@uirements needed in the calling routine in order to call a recursive su'routine or recursive function. D4 -f a a recursive routine does not stop recursing, it will recurse indefinitel&, thus hanging the program and producing no results. The program would need to 'e manuall& terminated. A4 + complete recursion tree for the recursive /i'onnaci function with an input of ! is as follows#
main6 5ib(2) step 1 5ib6 5ib(/) 7 5ib(0) step 10 step 11 step 1D
step 2
5ib6 5ib(0) 7 5ib(-) step 5ib6 5ib(-) 7 5ib(.) step ! step D 5ib6 return 5ib6 return .
step 0
step 12
5ib6 5ib(-) 7 5ib(.) step 1
step 1!
step B
step 11
step 1
5ib6 return -
5ib6 return -
5ib6 return . step A
step A
20A
0.19
>ui? @uestion answers for chapter 10 are as follows# 14 +n internal read is re@uired to convert an character string contain a numeric value. 24 +n internal "rite is re@uired to convert an real value into a character string. 4 The statement to convert the character string sNumU,12 2 into an integer varia'le iNum is as follows#
read (sNum, '()', iostat-cvtErr) iNum
!4 The statement to convert the integer varia'le iNumU2 ! into a character string sNum is as follows#
write (sNum, '()', iostat=cvtErr) iNum
0. <
?ui( ?uestion %ns*ers4 Cha"ter <
>ui? @uestion answers for chapter 20 are as follows# 14 "es, the date alone 'e o'tained 3i.e., without o'taining the time4 using the getRdateRtime34 s&stem service. 24 The answers are as follows# a4 2. '4 1. c4 1. 4 The hours can o'tained from the minutes '& dividing '& D0 and the minutes o'tained '& mod3hours,D04. !4 The statement is as follows#
call get_date_time(date=dStr)
14 The statement is as follows#

call get_date_time(time=timeStr, zone=zoneStr)
D4 The statement is as follows#

call get_date_time(values=valuesArr)
A4 -f there are no arguments entered on the command line, the getLcommandLargumentDE s&stem service call will return a 0. B4 The statement is as follows#
call get_command_argument(number=3, value=arg3, length=arg3length, status=arg3stat) &
20B
%""endix - 1 Fortran 95 @ey*ords
-n programming, a (e&word is a word or identifier that has a special /ortran 01 meaning. Ge&words are reserved in that the& can not 'e used for an&thing else such varia'le names.
The =ype as listed in the ta'le refers to the following#
statement Q implies a (e&word that starts a statement, usuall& one line unless there is a continuation LXL construct Q implies multiple lines, usuall& ending with Lend bL attri'ute Q implies it is used in a statement to further clarif& or specif& additional information.
/or reference, 'elow is a partial list of (e&words or reserved words. /or a complete list of (e&words, refer to the on6line GNU /ortran 01 documentation. <ey8ord
a**ocata3*e a**ocate assignment 3ac?space ca** case character c*ose comp*e+ contains cyc*e dea**ocate de=au*t do e*se e*se i= e*se8here end do end =unction
4ype
attri'ute statement attri'ute statement statement statement statement statement statement statement statement statement statement construct construct construct construct construct construct
2eaning
no space allocated here later allocate allocate memor& space now for varia'le means su'routine is assignment 3U4 'ac( up one record call a su'routine used in select case structure intrinsic data t&pe close a file intrinsic data t&pe internal su'routines and functions follow continue the ne*t iteration of a do loop free up storage used '& specified varia'le in a select case structure 6 all others start a do loop part of if, else if, else, end if part of if, else if, else, end if part of where, elsewhere, end where ends do loop ends function
200
:hapter 2A K +ppendi* G C /ortran 01 Ge&words

end i= end inter=ace end modu*e end program end se*ect end su3routine end type end 8here end=i*e e+it =ormat =unction i= imp*icit in inout integer intent inter=ace intrinsic inHuire ?ind *en *ogica* modu*e name*ist nu**i=y on*y open operator optiona* out construct construct construct construct construct construct construct construct statement statement statement construct statement and construct statement a (e&word for intent a (e&word for intent statement attri'ute construct statement statement attri'ute attri'ute statement construct statement statement attri'ute statement attri'ute attri'ute a (e&word for intent ends if ends interface ends module ends program ends select case ends su'routine ends t&pe ends where mar( the end of a file continue e*ecution outside of a do loop defines a format starts the definition of a function if3...4 statement LnoneL is preferred to help find errors the argument is read onl& the argument is read5write intrinsic data t&pe intent3in4 or intent3out4 or intent3inout4 'egins an interface definition sa&s that following names are intrinsic get the status of a unit sets the (ind of the following varia'les sets the length of a character string intrinsic data t&pe 'eginning of a module definition defines a namelist of input5output nullif& a pointer restrict what comes from a module open or create a file indicates function is an operator li(e O a parameter or argument is optional the argument will 'e written
210
:hapter 2A M +ppendi* G C /ortran 01 Ge&words

print pointer private program pu3*ic read rea* recursive resu*t return re8ind se*ect case stop su3routine target then type use 8here 8hi*e 8rite statement attri'ute statement and attri'ute construct statement and attri'ute statement statement attri'ute attri'ute statement statement construct statement construct attri'ute construct construct statement construct construct statement performs output to screen defined the varia'le as a pointer alias in a module start of a main program in a module 6 visi'le outside performs input intrinsic data t&pe allows functions and derived t&pe recursion allows naming of function result returns from e*its su'routine or function move read or write position to 'eginning start of a case construct terminate e*ecution of the main procedure start of a su'routine definition allows a varia'le to ta(e a pointer alias part of if construct start of user defined t&pe 'rings in a module conditional assignment a while form of a do loop performs output
211
:hapter 2A K +ppendi* G C /ortran 01 Ge&words
212
Index
+=$3+4.........................................................1B0p. +ccessing +rra& Elements.........................0A, 100 +ccessing :omponents...................................1 2 +:H+)3-4.................................................B2, 100 +:<$384........................................................100 +ctual arguments.............................................11B +ddition.............................................................21 +dvance clause..................................................A +-I+G3W4......................................................101 +llocate.............................................................0A +merican $tandard :ode for -nformation -nterchange..........................................................1 +rgument count...............................................1A +rgument -ntent...............................................11B +rgument .assing............................................110 +rguments.......................................................11B +rra& ;eclaration......................................01, 10A +$:--..................................................................1 +$-N384.........................................................100 +ssignment........................................................21 +T+N3J4.........................................................100 =ase 10................................................................! =ase 2..................................................................1 =inar& digit..........................................................1 =inar& Num'ers..................................................1 =it........................................................................1 =oolean..............................................................1 =&te.....................................................................1 :all statement..................................................11B :+$E statement................................................!0 :entral .rocessing Unit....................................... :haos Game......................................................0! :haracter...........................................................1 :haracter constant.............................................20 :haracter 9iterals..............................................20 :haracter )epresentation....................................1 :haracter $tring 5 Numeric :onversions.........1D :I.9J3J,"4..................................................101 :ommand line arguments........................1D0, 1A2 21 :ommand line options.....................................1A2 :ommandRargumentRcount34..........................1A :<II+N;R+)GUIENTR:<UNT34........102 :ompiler..............................................................! :ompiler Error.................................................. A :ompiling............................................................B :omple* constant..............................................20 :omple* 9iterals...............................................20 :omple* num'er...............................................1 :omponent......................................................1 1 :omputer program..............................................2 :onditional :ontrolled 9ooping.......................D1 :onditionall& :ontrolled 9oop E*ample..........D :onstant.............................................................11 :ontains...........................................................11B :oordinated Universal Time...........................1D0 :<$384...........................................................100 :ounter :ontrolled E*ample.............................10 :ounter :ontrolled 9ooping.............................1A :.URT-IE3T-IE4.........................................102 :&cle statement.................................................10 ;ate.................................................................1D0 ;+TER+N;RT-IE........................................102 ;ecimal Num'ers................................................! ;eclaration......................................................1 2 ;eclarations, E*tended $i?e Faria'les..............1D ;efinition........................................................1 1 ;erived ;ata T&pes.........................................1 1 ;irect access structure.......................................01 ;iscriminant......................................................!1 ;is( drive............................................................ ;ivision.............................................................22 ;o6loop..............................................................1A ;&namic +rra& +llocation.........................0A, 10B ;&namic +rra& ;eclaration...............................0D ;&namic ;eclaration.......................................10B E6notation..........................................................10 E@ual to.............................................................!1 Error Terminolog&............................................. A
:hapter K -nde* Escape character..........................................20, A0 E*it statement....................................................10 E*ponentiation...................................................2 E*ternal............................................................11A E*ternal declaration.........................................11B E*ternal )outines............................................11B /actorial function............................................11D /ile <pen...........................................................BA /ormal arguments............................................11B /<)I+T statement..........................................D0 /unctions.........................................................110 GetRcommandRargument34..............................1A GETR:<II+N;R+)GUINENT3NUI=E), F+9UE, 9ENGTH, $T+TU$4........................102 GetRdateRtime34...............................................1D0 GNUplot..........................................................10 Greater than.......................................................!1 Greater than or e@ual.........................................!1 Helper function................................................11A -+:H+)3:4..............................................B2, 100 -/ statement.......................................................! -/ THEN E9$E -/ statement............................!! -/ THEN E9$E statement.................................! -I.9-:-T N<NE..............................................1 -mplicit t&ping...................................................1 -mplied do6loop.................................................0B -nde*..................................................................01 -NT3+4.............................................................1B0 -nteger................................................................12 -nteger constants................................................10 -nteger 9iterals..................................................10 -ntent3in4..........................................................11B -ntent3inout4.....................................................11B -ntent3out4........................................................11B -nterface 'loc(.................................................11B -nternal.............................................................11A -nternal read.....................................................1D -nternal )outines.............................................11B -nternal write...................................................1D -ntrinsic /unctions.....................................2!, 110 -ostat................................................................1D -rrational num'ers.............................................1 Ge&word....................................................12, 200 Gind................................................................1Dp. Gind specifier.................................................1Dp. 9ENRT)-I3$T)4.....................................B , 100 9EN3$T)4.................................................B2, 100 21! 9ess than............................................................!1 9ess than or e@ual..............................................!1 9GE3$T)1,$T)24...........................................100 9GT3$T)1,$T)24...........................................100 9iterals...............................................................10 99E3$T)1,$T)24...........................................100 99T3$T)1,$T)24............................................100 9<G384..........................................................100 9ogic Error........................................................ 0 9ogical...............................................................1 9ogical constant................................................21 9ogical :onstants..............................................21 9ogical <perators..............................................!2 9oop..................................................................1A Iachine language................................................! Iagic $@uare...................................................111 I+J9<:3+14................................................101 I+JF+93+14................................................101 I-N9<:3+14..................................................101 I-NF+93+14..................................................101 I<;3)1,)24................................................1B0p. Iodule file......................................................1!A Iodules...........................................................1!1 Ionte :arlo.....................................................110 Iultidimensional +rra&s.................................10A Iultiplication....................................................22 N-NT3J4..........................................................1B0 Not e@ual to.......................................................!1 <'Eect file........................................................1!A <perands............................................................!1 <perating $&stem................................................2 <rder of <perations...........................................2 .arameter...........................................................11 .i estimation....................................................111 .rimar& $torage................................................... .rint =inar&.....................................................11! .rogram 9a&out...............................................11A .rogram $tatement..............................................A .&thagorean theorem.......................................110 >uadratic e@uation............................................!1 )andom +ccess Iemor&..................................... )andomRnum'er34...........................................1B1 )andomRseed34................................................1B1 )ational num'ers...............................................1 )ead statement.................................................. 0 )eal constants....................................................10 )eal 9iterals......................................................10
:hapter M -nde* )eal num'er2....................................................1 )E+93+4.........................................................101 )ecursion.........................................................11 )ecursive /actorial..........................................11D )ecursive relation............................................11 )ecursive su'routine.......................................11 )elational e*pression........................................!1 )elational E*pressions......................................!1 )elational <peration..........................................!1 )elational <perator...........................................!1 )elational <perator 3alternate4..........................!1 )esult varia'le.................................................11D )un6time Error.................................................. B $econdar& source file......................................1!1 $E9E:T :+$E $tatement................................!0 $elector lists......................................................!0 $ide Effects......................................................120 $ide6effect.......................................................120 $-N384............................................................100 $ingle ;imension +rra&s..................................01 $olid $tate ;rive................................................. $ource file............................................................B $>)T384.........................................................100 $tatic +rra& ;eclaration....................................0D $tatic ;eclaration......................................01, 10B $tring.................................................................20 $tring1...............................................................1 $u'program T&pes...........................................11A $u'programs....................................................11A $u'routines......................................................120 $u'script............................................................01 $u'traction........................................................22 $UI3+14.........................................................101 $&stem $ervices...............................................1D0 T+N3J4...........................................................100 Time.................................................................1D0 T)-I3$T)4...............................................B , 100 T&pe :hec(ing...................................................1! T&pe declaration................................................1! Unit num'er.......................................................BA Use $tatement..................................................1!D User6;efined /unctions..................................120 Using /unctions and $u'routines....................11B Falues arra&.....................................................1D0 Faria'le )anges.................................................1! Faria'le $cope.................................................11B 8hole num'er...................................................12 8rite statement..................................................20 Wone.................................................................1D0 .and....................................................................!2 .e@......................................................................!1 .ge......................................................................!1 .gt.......................................................................!1 .le.......................................................................!1 .lt........................................................................!1 .ne......................................................................!1 .not.....................................................................!2 .or.......................................................................!2 5U........................................................................!1 Z.........................................................................!1 ZU......................................................................!1 UU......................................................................!1 [.........................................................................!1 [U......................................................................!1
211

Introduction To Programming Using FORTRAN 95

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Introduction To Programming Using FORTRAN 95

Cargado por

Copyright:

Formatos disponibles

Introduction to Programming

Copyright Ed Jorgensen, 201 , 201!

1$ 2odu*es........................................................................................................................................ 14' viii

1A! 1AA 1AA 1AA

2$ 1ppendi+ " ( %ortran &' <ey8ords......................................................................................... 20& Inde+................................................................................................................................................... 21!

1.1 Why Learn Programming

1.! Com"lete Fortran 95 #ocumentation

1.$ What Is % Program

1.5 &"erating 'ystem

Screen / Keyboard / Mouse

Primary Storage (i.e., SSD, Disk Drive or Other Storage Media)

:hapter 2 K :omputer <rgani?ation

%ortran &' Program

12 ! = 1 1000 2100 10 ! 1 12 ! = 1 10 2 102 101 ! 100

The decimal s&stem is base 10 using the digits 0 through 0. !

:hapter 2 M :omputer <rgani?ation

:hapter 2 K :omputer <rgani?ation

!.1 +e.uired '/ills

"#ample $ %irst Program

The following trivial program illustrates the initial formatting re@uirements.

!.! Text ,ditor

Fortran 95 1 2asic ,lements

/or e*ample, some valid varia'le names are as follows#

$ome invalid e*amples include#

:hapter ! K /ortran 01 C =asic Elements

1 /or more information regarding integers, refer to# http#55en.wi(ipedia.org5wi(i5-nteger

:hapter ! M /ortran 01 C =asic Elements

/istorical Data 0yping

:hapter ! K /ortran 01 C =asic Elements

+dditional e*amples include#

+dditional e*amples include#

$.5 Continuation Lines

:hapter ! K /ortran 01 C =asic Elements /or e*ample,

-s e@uivalent to the following

Note that the 7X7 is not part of the statement.

$.0 #eclarations4 ,xtended 'i(e 3ariables

:hapter ! K /ortran 01 C =asic Elements

The following are some e*amples of integer constants#

+n integer must 'e a whole num'er 3with no fractional component4.

The following are some e*amples of real constants#

Hence, 2.A1E1 is 2.A1 101 or 2A1,000 and . one third.

8ould 'e displa&ed as

The dots enclosing the true and false are re@uired.

and to set it e@ual to 2.A1B2B1B , it would 'e#

and calculate the sum,

and calculate the difference,

and calculate the product,

and calculate the @uotient,

:hapter 1 M E*pressions /or e*ample,

and calculate the e*ponentiation,

5.! &rder of &"erations

Operation unar& 6 e*ponentiation multiplication and division addition and su'traction

and calculating the ans1 and ans2, as follows#

will set to ans1 to 120 and ans2 to A00 3'oth integers4.

5.$ Intrinsic Functions

5athematical ,ntrinsic %unctions

which will set z to 61.0. The varia'le pi is the input argument.

/or e*ample, given the following varia'le declarations,

and calculate the rnum1, inum2 and inum3,

which will set to rnum1 to 10.0, inum2 to !, and inum3 to 1. 2!

+ summar& of some of the more common intrinsic functions include#

+ more complete list of intrinsic functions in located in +ppendi* ;.

5.5 6ixed 6ode

:hapter 1 M Epressions /or eample,