F (programming language)

Short description: Programming language: compiled, structured, array language

F languageParadigm| Array, procedural, modular

|

Developer| The Fortran Company
Typing discipline| static, manifest
Influenced by
Fortran 95

F is a modular, compiled, numeric programming language, designed for scientific programming and scientific computation.[1] F was developed as a modern Fortran, thus making it a subset of Fortran 95.[2] It combines both numerical and data abstraction features from these languages. F is also backwards compatible with Fortran 77, allowing calls to Fortran 77 programs. F was implemented on top of compilers from NAG, Fujitsu, Salford Software and Absoft. It was later included in the g95 compiler.

## Contents

* 1 Overview
* 1.1 Operators
* 1.2 Data types
* 1.3 Statement and control flow
* 2 References
* 3 Bibliography
* 4 External links

## Overview

F is designed to be a minimal subset of Fortran, with only about one hundred intrinsic procedures.[3] Language keywords and intrinsic function names are reserved keywords in F and no other names may take this exact form. F contains the same character set used in Fortran 90/95 with a limit of 132 characters. Reserved words are always written in lowercase. Any uppercase letter may appear in a character constant. Variable names do not have restriction and can include upper and lowercase characters.

### Operators

F supports many of the standard operators used in Fortran. The operators supported by F are:

* Arithmetic operators: `+`, `-`, `*`, `/`, `**`
* Relational operators: `<`, `<=`, `==`, `/=`, `>`, `>=`
* Logical operators: `.not.`, `.and.`, `.or.`, `.eqv.`, `.neqv.`
* character concatenation: `//`

The assignment operator is denoted by the equal sign `=`. In addition, pointer assignment is denoted by `=>`. Comments are denoted by the `!` symbol:

variable = expression ! assignment
pointer => target ! pointer assignment

### Data types

Similar to Fortran, the type specification is made up of a type, a list of attributes for the declared variables, and the variable list.[2] F provides the same types as Fortran, except that double precision floating point variables must be declared as real with a kind with a kind parameter:

! type [,attribute list] :: entity declaration list
real :: x, y ! declaring variables of type real x,y without an attribute list
integer (kind = long), dimension (100) :: x ! declaring variable of type big integer array with the identifier x
character (len = 100) :: student_name ! declaring a character type variable with len 100

F does not have intrinsic support for object-oriented programming, but it does allow for records:[2]

type, public :: City
character (len = 100) :: name
character (len = 50) :: state
end type City

Variable declarations are followed by an attribute list. The attributes allowed are `parameter`, `public`, `private`, `allocatable`, `dimension`, `intent`, `optional`, `pointer`, `save` and `target`. The attribute list is followed by `::`, which is part of the syntax. F also allows for optional initialization in the list of objects. All items in a list will have the same attributes in a given type declaration statement. In addition, declarations are attribute oriented instead of entity oriented.

### Statement and control flow

F supports 3 statements for control flow: `if`, a basic conditional, `case`, a switch statement, and `do`, a conditional while loop. The `return`, `stop`, `cycle`, and `exit` statements from Fortran may be used to break control flow.

real :: x

do i = 100
x = x+i
print*,i
cycle
end do

max : do
if (x > y) then
exit max
end if
x = y
end do max
stop

if (x < y) then
x = x + y
else if ( x > y) then
x = y - x
end if

select case (maximum):
case (0)
x = 0
case (1)
x = 1
case (5)
x = 5
case default
x = 10
end select

F places a heavy emphasis on modular programming.

program main
! Insert code here
end program main

Placing procedures outside of a module is prohibited. F supports most of the functions and subroutines found in the Fortran 95 standard library. All functions in F are external by default and require a result clause that returns the value of a function.[2] F supports recursion.

All of the intrinsic procedures found in Fortran 95 may be used in F, with the exceptions of `achar`, `iachar`, `lge`, `lgt`, `lle`, `llt`, `transfer`, `dble`, `dim`, `dprod`, and `mod`.

## References

1. ↑ The Fortran Company. "All About F". http://www.fortran.com/F/about_f.html. Retrieved 2014-04-28. [|permanent dead link|dead link}}]
2. ↑ 2.0 2.1 2.2 2.3 Adams, Jeanne. "The F Language". https://www.cisl.ucar.edu/zine/96/fall/articles/2.F.language.html. Retrieved 2014-04-28.
3. ↑ "The F Programming Language Tastes Like Java". https://www.fortran.com/F/java.htm. Retrieved 2014-04-29.

## Bibliography

* Walter S. Brainerd, Charles H. Goldberg, and Jeanne C. Adams: "Programmer's Guide to F", Unicomp, 1996.
* Michael Metcalf and John Reid: "The F Programming Language", Oxford University Press, Oxford and New York, 1996.
* Gehrke, Wihelm (1997-05-30). The F Language Guide. Springer. ISBN 978-3-540-76165-5. https://link.springer.com/book/10.1007/978-1-4471-0989-1.
* Robin A. Vowels: "Algorithms and Data Structures in F and Fortran", Unicomp.
* Loren Meissner: "Essential Fortran 90 & 95", Unicomp, 1997.

## External links

* F Programming Language Homepage
* g95 compiler

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/F (programming language). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=F_(programming_language)&oldid=242162"