Character (String) Data Character data in an programming language is always a little tricky. CHARACTER name (for single character variables) CHARACTER name(n) for strings of characters The tricky part always comes down to: CHARACTER name(100) = ‘Duncan Buell’ The first 12 characters of this string are obviously ‘Duncan Buell’, but what gets stored in the rest of the string? CSCE 206

Character (String) Data Character strings in scientific computing are usually labels on other data. There are functions that handle character strings. There is a collating sequence or sort order for character strings. Usually character data will be sorted lexicographically (in dictionary order), with the strings left justified. (We may or may not get to the issue of the collating sequence.) CSCE 206

The End CSCE 206

Subprograms The power of a computer comes from conditional execution (IF-THEN-ELSE) and from iteration (DO loops). Programs would be much less useful if done as straight line code. Subprograms in Fortran are either subroutines or functions. Functions work like mathematical functions—arguments are passed in to the function, and a function value is returned. Subroutines allow for returning more than one value. CSCE 206

Builtin Functions See pages 324-325 for some builtin functions. CSCE 206

Functions DO n = 1, 10 PRINT *,a*n**2 + b*n + c END DO can be replaced by f = f_of_n(a,b,c,n) PRINT *,a,b,c,n,f then later on INTEGER FUNCTION f_of_n(a,b,c,n) INTEGER :: a,b,c,n f_of_n = a*n**2 + b*n + c RETURN END CSCE 206

Functions -- Rules Variables in the calling program are completely independent of variables in the subprogram, so you can have an x in each and they are different. The region of code over which a variable is defined is called its scope. Variables must be declared in the subprogram. If the value of variable that is an argument to a subprogram is changed inside the subprogram, then that change is propagated to the calling program as well. Unless the INTENT(IN) spec is used. CSCE 206

The End CSCE 206

Functions—Internal, External, Modules Four ways to do functions—this is too many, IMO I cover this only to explain what you’ll find in the book. Essentially, the only differences are in the scope of the function names and the variables. And everything I say about functions is also true for subroutines CSCE 206

First: A Word about Compilation When the compiler has finished, virtually all of the symbols in your program have disappeared This sort of includes the function names themselves, which is the point of this whole section of the lecture. If your calling program wants to call a function, there has to be a way for the function’s symbol (i.e., name) to be recognizable by the compiler. CSCE 206

ONE: EXTERNALLY Defined Functions PROGRAM version_one IMPLICIT none INTEGER my_function f = my_function(arguments) END PROGRAM version_one INTEGER FUNCTION my_function(arguments) my_function = whatever RETURN END my_function The function code lies OUTSIDE the calling program. CSCE 206

TWO: INTERNALLY Defined Functions PROGRAM version_one IMPLICIT none ! INTEGER my_function (NO LONGER NECESSARY) f = my_function(arguments) STOP CONTAINS INTEGER FUNCTION my_function(arguments) my_function = whatever RETURN END my_function END PROGRAM version_one The function code lies INSIDE the calling program. CSCE 206

Functions—Internal, External, Modules External: The function name must be declared and typed in the calling program, because the function “isn’t visible” outside the calling program. Internal: The function name must NOT be declared, because the INTEGER FUNCTION (or similar) declaration does the declaration. But you need the CONTAINS statement—in essence, this tells the compiler that what follows are functions/subroutines and not CSCE 206

Functions—Internal, External, Modules External: The functions are compiled as independent units. All the variables have local scope. This has advantages we won’t go into now. Internal: Everything about the functions can be hidden, which facilitates the current fashionable mode of object-oriented programming. Variables in the main program have global scope unless they are overridden in subprograms. Not everyone is a fan of OO. I personally find the internal method to be harder to keep straight in my head, but I’ll deny this if you report me to others. CSCE 206

THREE: Functions As Modules It is possible to define a function in one file and its calling program in another file, and then to compile the two files in a multistep process. In this case, there needs to be a way to link the symbols together, because the compilation processes are independent and wash away all the symbols. This is the way a lot of packages are written. (This makes your own functions look like the builtin functions.) CSCE 206

Functions—Internal, External, Modules External: The functions are compiled as independent units. This has advantages we won’t go into now. Internal: Everything about the functions can be hidden, which facilitates the current fashionable mode of object-oriented programming. Not everyone is a fan of OO. But don’t say I told you so. CSCE 206

Functions—Bottom Line With external functions, or with separately compiled files, the ONLY symbols that still exist after the compile step are the names of the subprograms. All other symbols are local to the functions and have disappeared by the time the compilation finishes. This isn’t all that difficult to deal with. If you forget to declare something, then the compiler messages will indicate that by saying that the variables aren’t defined. CSCE 206

The End CSCE 206

Subroutines Functions take arguments and return a single value, just as does a mathematical function. Sometimes you want to use a subprogram because you’re going to use the same piece of code over and over again, and you want to encapsulate that code (and be able to guarantee that you can use variable names that won’t conflict with names used elsewhere in the program). CSCE 206

Subroutines SUBROUTINE my_sub_name(arguments) instead of REAL FUNCTION my_func_name(arguments) Called with CALL my_sub_name(arguments) instead of by invoking with variable_name = my_func_name(arguments) CSCE 206

Subroutines Since subroutine names are not symbols with data types, they do NOT need to be declared. And the name is NOT given a value inside the subroutine before executing the RETURN. Otherwise, all the same rules apply, with regard to local or global scoping, internal or external, etc…. CSCE 206

The End CSCE 206