Useful FortranNotes

Logical operands:.and. , .or. , .eqv. , .neqv. , .not.----------------------------------------------------------------------------------String concatenate:“The quick brown fox”//” ”//”jumps over the lazy dog”----------------------------------------------------------------------------------Use type_name(expr-list) to initialize a derived data type, for example : type stringcharacter(20)::valueinteger::lengthend type stringand later:type(string)::s = string(“This is a string”,16)-------------------------------------------------------------------------------- Assignment of a pointer:X => z, X is a pointer, z is a variable---------------------------------------------------------------------------------Also we can useX => null() to let X pointing to a null address------------------------------------------------------------------------------------------------------------------------------------------------------------------Select construct[name:] select case (expr)case selector [name]BlockDo(loop) construct:Do i = 1,n…end doUse “continue”(or ”cycle”)and “exit” in Fortran “do” loops as we use “continue” and “break” in C “while” loops“continue” can also be used as a “do thing” place holder---------------------------------------------------------------------------------Taking function as an argument:Function “minimum” takes another function “func” as an argument and minimize it.In this following example also notice how “internal” functions are declared and used. Note that theA function/subroutine with optional arguments can be called like:Call some_subroutine(n,f,x, option1=.yes., option3=.no.,)While you can guess that “option2” is omitted.In the function/subroutine itself, use intrinsic procedure present(option2) is test if a particular argument is being provided. If not, present(option2) will return .false.When defining a funct ion/subroutine, use “OPTIONAL” attribute if this argument is optional.---------------------------------------------------------------------------------------------------An example of a recursive function. If a function calls itself, the function name has ambiguous meanings between “a call to itself” and “its return value”. In this case, add a “result()” clause after function name to give another name to its return value. If a function is indirectly recursive, i e. it calls some functionWhen a string is used as argument and its length is unknown, we may use character(len=*)::string or simply character(*)::string as the declaration. We can use len(string) in runtime to actually test its length ----------------------------------------------------------------------------------------------------R andom number generator in fortran is subroutine “random_number(r)”. Use “call random_number(r)” to get a random value between 0.0 and 1.0 written in r.----------------------------------------------------------------------------------------------------(Not confirmed) Whenever a pointer appears on LHS of a statement, the RHS could be pointers, variables, arrays, pointer to arrays, etc. However always use ‘=>’ to indicate a change of pointer itself no matter whether the RHS is a variable or a pointer. If we use a ‘=’when the LHS is a pointer, it’s always a change of the object associated by the pointer.-----------------------------------------------------------------------------------------------------Looks like an allocated array will automatically deallocate if it’s out of domain, except that a “save”attribute is applied. But “save” attribute is more like “static” in C.It’s saved so it can be visited when the function is called next time. Can we use a function to allocate some memory for outer space? Looks like it’s ok. However when no variable is associated with that piece of memory, it’ll be released (Looks likeUse “associated(p)” to test if p is a null pointer. Use nullify(p) or p=>null() to make p dissociated. But nullify(p) won’t deallocate the memory p points at. Except p is the only variable pointing to that memory at this time.-----------------------------------------------------------------------------------------------allocate() and deallocate() can take an extra argument as allocate(array(x,y),stat = flag) ordeallocate(array, stat=flag). flag should be an integer. flag value after calling the procedure indicateswhether the call is successful (flag==0) or not (flag!=0). Try to deallocate an array/pointer which is already deallocated will yield non-zero stat value.Also, after allocation, we can use allocated(array) to test if the array is successfully allocated, given that we didn’t test it when calling allocate().-----------------------------------------------------------------------------------------------Operations that can apply to each element of an array is called “elemental”. Intrinsic procedures such as +, -, *, /, sin(), cos(), etc are all elementary. User defined procedures are NOT automatically elementary. We can define the polymorphism to let it be elemental, like the example below, operator(+) is now elemental as long as only 1-dimensional arrays are involved. Notice “size(a)” can dynamically determine the array length of an input array.An alternative way is to declare it as “elemental”. See the 4th nextWhere statement:where (array_name > 0)array_name = some_new_valueend where-----------------------------------------------------------------------------------------------Forall statement:forall statement is a little bit like “for” statement in C:forall(i=1:n, j=1:n)do something related to i,jend forallForall statement can also be “forall(i=1:n, j=1:n, array(i,j)/=0)”, or nested likeforall(i=1:n)forall(j=1:n)some actionend forallend forallTechnically, DO while asks the program to do the loop following the exact order, while forall statement allows the loop to be completed in any order. Thus forall tells the cpu to “go parallel if it’s possible”-----------------------------------------------------------------------------------------------We can “name” do loops, if statements, select clauses, etc, in case if a loop is large, we can keep track on which level we are in if we meet an “end” statement. It’ll also help compilers and debuggers to generate diagnostic information if something goes wrong.----------------------------------------------------------------------------------------------“pure” attribute added in front of a function means this function has no “side effect”, i e. it won’t change values of it arguments or any global variable. It’s like “const function” in C. Note that there is no “pure” subroutin e, since subroutines are meant to have “side effects”-----------------------------------------------------------------------------------------------“elemental” attribute allows a function to be elemental. Elemental functions must be “pure”, and its return value must be a scalar instead of an array (not even the array is fixed length). If an elemental function calls another function, the other function must also be elemental.-------------------------------------------------------------------------------------------------Can we declare “array of pointers”? Not directly since integer,dimension(:),pointer::p defines a pointer which points to a array (1 pointer) but not an array of pointers (multiple pointer). We can work around this by wrap a pointer into a type structure, and define arrays of that type.-------------------------------------------------------------------------------------------------Array constructor. Use array = (/1,2,3,4/) to construct an array. Use array = reshape((/1,2,3,4/),shape = (/2,2/)) to construct a multi-dimensional array.-------------------------------------------------------------------------------------------------The attributes of “private” and “public” can be used in modules and derived typesreal, public::ainteger,private,dimension(:)::arrayor if we defined some functions in this module, and later specify that:private::function_name1, function_name2-------------------------------------------------------------------------------------------------If some function arguments are optional, use the “optional” attribute for dummy arguments. As said before, use the intrinsic method “present()” to determine whether an argument is given and whether it needs a default value.-------------------------------------------------------------------------------------------------The “save” attribute equals “static” in C. It can appear in functions/subroutines and modules and maintain its value during the whole lifetime of a program-------------------------------------------------------------------------------------------------Use “date_and_time()” intrinsic function to get date and time.Use associated(p1,variable) or associated(p1,p2) to find whether p1 points to variable or p1,p2 point to the same address.-------------------------------------------------------------------------------------------------READ(*,*) var1,var2 takes two *. The first * means the input device is standard input. The second * means “list-directed input”,or “read whatever you need” reading mode.-------------------------------------------------------------------------------------------------Strings (“character(len=xx)::string”)can be compared using standard relational signs such as <, >, ==, >=, The difference between <,>,>=,<= and LGT, LLT, LGE, LLE: <,>,>=,<= depends on the characters set the computer is using, if the computer uses a character set other than ASCII, the result may be different. On the other hand, LGT, LLT, LGE, LLE are guaranteed to produce result based on ASCII order. So always use LGT, LLT, LGE, LLE since they are portable. However there is no equivalent function as ==, since string equivalency doesn’t depend on character set, just use == and /= if we want to check whether two strings are equal or not.Some methods for strings: len(), len_trim(), trim(). Some methods just for characters: achar(integer), ASCII index to char, iachar(character), character to ASCII index. “a” here means ASCII. char(integer) and ichar(character) are also available, given that char() and ichar() are based on the computer’s local character set. So always use iachar() and achar()!INDEX(str1,str2,back): returns the location of str2 appears in str1. Returns 0 if str2 is not substring ofstr1. “back” is an optional logical argument which, if present, makes the search backward.-------------------------------------------------------------------------------------------------Formatted output:I refers to integer, F refers to real, L refers to logical, E refers to scientific, A refers to character/string as we already know. ES also refers to scientific but will show a number like 1.3E4 (E will show it like 0.13E5). nX means adds n blank spaces. T is very useful, T51 means jumping to column 51 immediately. We can also jump “backward” to make output overlaps.Output expression can be grouped, such like write(*,'(3(I3,3X))'),i,i+1,i+2Slash ‘/’ equals \n in C, just starts a new line.It’s advised in Fortran to allow one blank space at the beginning of each line, to avoid some archaic mechanism of line change by placing a ‘1’ at the beginning of each line.-------------------------------------------------------------------------------------------------In “READ”, formats are similar to WRITE, but there are slight differences.When reading a string, if we specify character(len=10) str; READ(*,’(A)’) str, then it’ll read 10 characters and write into str. But if we READ(*,’(A5)’) str, it’ll only read 5 characters and write to the left half of str. If we READ(*,’(A15)’), then it’ll read 15 characters from the input, but only the right 10 characters from what was read can be written into str.‘/’ can be used to ignore the rest of the line; X can be used to skip a certain length of fields.‘T’ can be used to jump to a specific location, or jump back to read the data again.If a READ() did no read enough data, it will simply stop, and the current line it was reading will be discarded. The next READ() will start a new line to continue reading.-------------------------------------------------------------------------------------------------File descriptor is a integer number, it can be obtained from OPEN() method. There are some default file descriptors that are not guaranteed to work on every machine, including 5 for stdin, 6 for stdout, 0 for stderr. Avoid using them but be sure once encountered, we know what it means. However, asterisk * is guaranteed to be stdin/stdout on any machine.READ(UNIT=int_expr, FILE=char_expr, STATUS=char_expr, ACTION=char_expr, IOSTAT=int_expr) UNIT: file descriptorused. It must be nonnegative. Note it’s an INPUT parameter not an OUTPUT parameter. We need to specify a number for it instead of waiting the system to return a number for us! FILE: file name to openSTATUS: ‘OLD’, ‘NEW’, ‘REPLACE’,’SCRATCH’,’UNKNOWN’, optional, default ‘UNKOWN’ACTION:’READ’,’WRITE’,’READWRITE’IOSTAT: returns 0 means successful, otherwise unsuccessful and it’s an error code.If we want to read from an opend file, each time we read, we should used IOSTAT flag: READ(file_descriptor, fmt, IOSTAT = status)and check the IOSTAT flag status. If it’s non-zero, then we already reached the end of file. We should terminate reading and exit the loop.We can use BACKSPACE(file_descriptor) to go back one record(I think which means one line), or use REWIND(file_descriptor) to return beginning of file.-------------------------------------------------------------------------------------------------Note that READ in fortran and also read from a string, like sprintf in C or istringstream in C++. Similarly write statement can also write to string, just use:READ(string, ‘(I3, F4.8, …)’), i, a,or WRITE(string, fmt), variables..-------------------------------------------------------------------------------------------------character(len=*)::str is usually used in functions/subroutines as dummy variables. It simply means “I don’t know it’s length”. It’s memory space will be allocated once actual arguments are passed.-------------------------------------------------------------------------------------------------What’s the difference between a function/subroutine defined not in a module/program or is defined within a module/program? Function/subroutine defined outside of module/programs are said to havehowever the result is wrong since a real number is mistreated as an integer.Conclusion: always define subroutine/functions within modules, or use explicit interfaceP.S. when used assumed-shape or assumed-length arrays as dummy variables, explicit interfaces are mandatory. Also for functions they need to be declared in callers like regular variables if not defined in modules.-------------------------------------------------------------------------------------------------Some useful array functions:ALL(mask), true if all values are true; ANY(mask), true if any one value is true;COUNT(mask), count number of trues;DOT_PRODUCT(A,B), dot_product of two vectorMATMUL(A,B) matrix product of two conformable matrixesMAXLOC(array, mask), MAXVAL(array, mask), MINLOC(array,mask), MINVAL(array,mask); find location/value of maximum/minimum element in array, mask is optional but if given, elements that are masked out are ignored.PRODUCT(array,mask), SUM(array,mask); product/sum of elements in array given mask is true. mask is optional.RESHAPE(array,shape), TRANSPOSE(array); they are self-evident;In the above functions, “mask” means an array with all logical elements.-------------------------------------------------------------------------------------------------If we want to return a string from a function, use form A instead of form B: B is OK but is an obsoleteThere is no such thing like atoi() or atof() in Fortran. Instead, we can use READ to convert a string into floating number or integer: “READ(string, ‘(F)’), a”, Assuming string is type CHARCTER(*) and a is type REAL-------------------------------------------------------------------------------------------------We can define types of real numbers using REAL(KIND=kind_number)::a to specify a kind for the real number. However the kind_number is dependent on CPU type. For example for x86 systems,kind_number usually means number of bytes it takes, such as kind=4 means a “single” precision floating number like “float” in C, and kind=8 means a “double”. The only portable way to specify a kind_number is to use:kind_number = SELECTED_REAL_KIND(p=precision,r=range)(either p or r is optional, but not both) to specify the precision and range we need. For example: kind_number = SELECTED_REAL_KIND(p=6, r=37)means a precision of 6 digits and range of +-10^37. Other useful methods include:KIND(x): the kind of some number xPRECISION(x):, RANGE(x)For a “double”, it’s precision and range is 15 and 307. So SELECTED_REAL_KIND(15,307) will be guaranteed to yield a 8 byte “double” on every computer.“float” actually is (6,37)Note: The largest possible integer kind on my computer is actually int64 with range 10^18An intrinsic function called DBLE() can convert a number into double precision number, but as just said what “double precision” means is CPU dependent.-------------------------------------------------------------------------------------------------Functions related to COMPLEX type:CMPLX(a,b,kind): conversion from two reals to a complexREAL(c), INT(c): convert the real part of a complex into a real or an integerAIMAG(c): convert the imaginary part of a complex into a realCABS(c): absolute valueCONJG(c): its conjugate-------------------------------------------------------------------------------------------------SEQUENCE attribute asks the compile to arrange elements within a type structure accorder to their order in the source code. It’s useful when a type structure is passed to a module written in another language (interoperability with C perhaps).-------------------------------------------------------------------------------------------------extension name.Type can also take parameters, like:(NOT YET IMPLEMENTED IN MOST COMPILERS)type vector(kind,n)INTEGER,KIND::kind = KIND(0.) if kind is not given , use KIND(0.) as defaultINTEGER,n = 3 if n is not given, use 3 as defaultREAL(kind),DIMENSION(n)::vend type vectorThe type parameters here are like template parameters in C++, except that they can’t specify data types (, which can implement metaprogramming). Unfortunately this feature has not supported yet in 2014 by compilers such as gfortran.Types which are not SEQUENCE or BIND(C) can be extended (inherited), like this:type, EXTENDS(vector):: vector_with_colorINTEGER::colorend type vector_with_colorGiven a vector_with_color object named vc, we can refer its elements like vc%v or vc%parent%v, both are OK. (After testing, vc%parent%v don’t work on my compiler, so just use vc%v).Types can have associated functions(member function). Member functions must be declared as procedure,pass::function_name() but defined outside the type but inside the module. “pass” means the first argument of the function will be the object itself.If we want to use functions/subroutines defined within a module, we can simply use that module. But there are cases where function/subroutines are not defined within a module, for example legacy codes, or library written in C. In this case, we need to define interfaces within caller module. The interface simply repeats the header of called functions/subroutines. If we have a legacy library consists of a large set of functions/subroutines written without any module, we can create an interface for each function/subroutine and put all interfaces in a single module. Using the “interface module” allow us to call those functions/subroutines without further difficulty.-------------------------------------------------------------------------------------------------Interface GenericFunctionNameSubroutine AppliedToFirstTypeOfInput(a)…End SubroutineSubroutine AppliedToSecondTypeOfInput(a)…End Subroutine…End Interface GenericFunctionNameThen later you need to define AppliedToFirstTypeOfInput and AppliedToSecondTypeOfInput separately (within the same module which contains the interface section). Then later you can call the generic function name GenericFunctionName() to deal with different types of functions.Methods bound to derived types(member functions) can also be generic. You need to : TYPE::pointREAL::x,yCONTAINSGENERIC::add=>point_plus_point, point_plus_scalarThen define point_plus_point and point_plus_scalar like normal member function.Operators can also be overwritten like:INTERFACE OPERATOR(operator_symbol)MODULE_PROCEDURE function_1MODULE_PROCEDURE function_2…END INTERFACEThen define function_1 and function_2 normally.for (=), it must be INTERFACE ASSIGNMENT(=) and the overloaded method must be a subroutine. Corresponding operators overloading in member functions are:TYPE ……CONTAINSGENERIC::ASSIGNMENT(=) => assign_subroutineGENERIC::OPERATOR(+) => plus1, plus2, plus3,……END TYPE …-------------------------------------------------------------------------------------------------When declared Public, attributes/methods can be calledWhen Private, can’t access from outside module. When Protected, it’s read-only outside of module. There are several ways to declare the data hiding level:Way 1: add public, private, protect to each attribute:INTEGER,PUBLIC::iREAL PRIVATE FUNCTION f()Way 2: use a list to declare who is private, who is publicPUBLIC:: i, fPRIVATE::a,jWay 3: use an empty list PRIVATE to make all of them private, then a public to say what are exceptions: PRIVATEPUBLIC::a,i<- (Preferred)-------------------------------------------------------------------------------------------------USE module_name, ONLY:fun1, fun2_renamed=>fun2allows partial use of a module and renaming-------------------------------------------------------------------------------------------------subroutine GET_COMMAND(command,length,status): writes the whole command(including program name into command. If command has not enough space to write the whole string, state /=0) status==0 if successfulsubroutine GET_COMMAND_ARGUMENT(number,value,length,status): writes i-th argument into value. status ==0 if successful. 0-zero argument is the program name itself.-------------------------------------------------------------------------------------------------It tries to find an environmental variable with the name same as “NAME” and writes its value into “VALUE”. status == 0 if found, and writing into VALUE is successful. If TRIM_NAME is .true., it tries to find an environmental variable named as trim(NAME).-------------------------------------------------------------------------------------------------If we want a pointer to associate with a (static) local variable, the variable must be declared as TARGET. However if a pointer is associated with an allocated data, there is no such restriction because the allocated data don’t have to be declared, like this:INTEGER, pointer::piAllocate(pi); pi = 3;A pointer can be in three states, undefined as it’s first declared; associated as it’s a nor mal pointer and pointing to something; dissociated means after pi=>null() or nullify(pi); If we use associated(pi) to test it, it will give True only in the second case.The only reason to choose null() instead of nullify is at the moment of declaration, only => null() is usuable:INTEGER, pointer::pi => null(); but nullify() can’t be used here.Whenever a pointer appears in an expression, except in the LHS of a ‘=>’, always treat it just like the variable it points to.Caution: Use allocatable arrays won’t cause memory leak, but using pointers to allocate space withoutattributes apply to this module. 2. Easy to use, just use the module.∙Use “type Unit” to define a class∙Use “type, extends(Unit):: AdvancedUnit” to inherit a class∙Use “class(AdvancedUnit),pointer::p” to declare a pointer that can be associated wit h any object of Unit family so it can exhibit polymorphism.∙This is no such thing as “constructor”, when declare an object, use Unit::u = Unit(v1, v2) to initialize its first and second members with v1 and v2. If its members are private, then we can’t use this kind of method to construct an object. There is no “Constructor” when enables us to construct an object from a function.∙Private members can’t be accessed from inheriting classes∙Use “FINAL” keyword to mean it’s a finalizer like this: finalizer must b e a subroutine with no∙∙∙DEFERRED attribute denotes it’s a virtual function. A class with a virtual function is a virtual class which can’t have objects.。