Speed. Dependability. Great Tech Support. Lahey/Fujitsu Fortran 95.
The standard for Fortran programming from the leader in Fortran language systems.
We've combined our 40 years of producing award-winning Fortran language systems with Fujitsu's compiler expertise and high-performance code generator to deliver the most-productive, best-supported Fortran 95 language system for the PC.
Whether you write new Fortran programs or downsize existing applications, you need speed, dependability, and great tech support. You need LF Fortran v7.3!
LF Fortran v7.3 Delivers!
LF95 v7.3 is available in two configurations: Express and Professional:
LF95 Express includes the powerful Lahey/Fujitsu Fortran 95
optimizing compiler, linker, command line debugger, librarian, support
for creating DLLs and calling the Windows APIs, online documentation, and
free e-mail support.
PRO adds Microsoft's Visual Studio 2010 Shell with Lahey's exclusive Fortran Integration,
the Winteracter Starter Kit, WiSK, for creating Windows GUIs
and displaying graphics, Polyhedron's Automake utility, Fujitsu's WinFDB
Windows debugger, the Coverage Analysis Tool that detects unexecuted code
and performs range-of-operation checking, the Sampler Tool (an execution
profiler) that helps tune program performance, Fujitsu's Visual Analyzer, the Fujitsu SSL2 math
library (an extensive library and a proven performer on Fujitsu mainframes
and workstations) and the Fujitsu C compiler.
LF Fortran 95
LF Fortran 95 7.3 offers improved execution performance on most Fortran 77 and 90 codes. The new optimizations help performance on Pentium(R) 4 and Xeon(TM) chips. "We tested v7.3 Win32 optimizations on a 2.4GHz P4 with 512 MB of PC2100 RAM, running Windows XP, using Polyhedronís (www.polyhedron.com) Fortran benchmarks. Specifying the new switches -tp4, -sse2, -zfm, -o2, and -inline the 90 benchmarks ran an average of 15.4% faster and the 77 benchmarks 4.4% faster than they did when built with LF Fortran v7.0."
LF Fortran 95
Program Reconstruction Optimizations
- Constant folding
- Common subexpression elimination
- Copy propagation
- Strength Reduction
- Algebraic simplifications
- Dead code elimination
- Peephole optimization
- Loop invariant code motion
- Transform array element to simple variable
- Local Instruction scheduling
- Address calculation optimization
- Array optimization
- Loop unrolling
- Loop interchange
- Inlining mathematical functions
- Stack optimization
- Inline user-defined
- Pentium/Pentium PRO/Pentium 4 instruction
- Using fast input/output libraries
- Prefetch Pentium III / Athlon
- SSE2 instruction optimizations
- Enable flush-to-zero mode for SSE2
Link Fujitsu C and Borland C++ Object Files.
LF Fortran 95 supports static
linking with Fujitsu C and Borland C++ Object Files. Combine your Fortran and C/C++
code into one executable. For the routines you don't want to develop yourself,
you can also link with C/C++ routines from commercially available libraries.
Interfaces to Visual Basic, VC++, Borland C++, Delphi, Microsoft .NET languages.
Create 32-bit Windows
DLLs from your Fortran routines and call the Fortran routines from 32-bit
Windows programs created with Microsoft Visual Basic, Microsoft Visual
C++, Borland C++, Borland Delphi, and Microsoft .NET languages.
LF Fortran 95 supports direct
calls from Fortran to functions in the Win32 API. For a narrow range of
applications, this might be the last little bit of glue you need to pull
off your project. Note that this is not for the faint-hearted! You'll need
to be a Windows programmer to get all but the most basic functionality.
That's because the API was written to be called from C. And consequently,
arguments need to be passed as C expects them. Structures and callback
routines pose additional problems. Clearly, this would be a difficult way
to build a Windows application from scratch.
LF Fortran 95 extends its
language support in other directions adding many legacy Fortran features,
including VAX structures and the various UNIX service routines. These features
further facilitate your move to cost/performance efficiency on the PC platform:
- Unlimited number of continuation lines in free or fixed source form
- DO UNTIL statement
- FIND statement
- STRUCTURE and END STRUCTURE statements
- UNION and END UNION statements
- MAP and END MAP statements
- RECORD statement
- Non-standard POINTER statement
- AUTOMATIC statement
- STATIC statement
- VALUE statement
- BYTE statement
- Hollerith constants
- Alternative forms of binary, octal, and hexadecimal constants
- Binary, octal, or hexadecimal constants in a DATA, declaration statement
- Period structure component separator
- IMPLICIT UNDEFINED statement
- Namelist input/output on internal file
- FORM = 'BINARY'
- TOTALREC specifier
- STATUS = 'SHR'
- Gw, $, \, and R edit descriptors
- LOC intrinsic function
- The following service subroutines: ABORT, BEEP, BIC, BIS, CLOCK, CLOCKM, DATE, EXIT, ERRSAV, ERRSTR, ERRSET, ERRTRA, FDATE, FREE,GETARG, GETDAT, GETLOG, GETPARM, GETTIM, GMTIME, IBTOD, IDATE, IETOM, ITIME, IVALUE, LTIME, MTOIE, PERROR, PRNSET, QSORT, SETRCD, SETBIT, SIGNAL, SLEEP
- The following service functions: ACCESS, ALARM, BIT, CHDIR, CHMOD, CTIME, DRAND, DTIME, ETIME, FGETC, FPUTC, FSEEK, FSTAT, FTELL, GETC, GETCWD, GETFD, GETPID, HOSTNM, IARGC, IERRNO, INMAX, IOINIT, IRAND, JDATE, KILL, LNBLNK, LONG, LSTAT, MALLOC, NARGS, PUTC, RAN, RAND, RENAME, RINDEX, RTC, SECOND, SECNDS, SETDAT, SETTIM, SHORT, STAT, TIME, TIMEF, UNLINK
ANSI/ISO-Compliant Fortran 95.
LF Fortran 95 is a complete
implementation of the ANSI/ISO Fortran 95 standard. Fortran 95 offers some
small but important improvements over Fortran 90, including the ability
to create your own elemental procedures, default initialization for structure
components, the NULL intrinsic for initializing pointers, the FORALL construct,
and a standard CPU_TIME intrinsic procedure.
IEEE Standard 754 support
IEEE Standard 754 defines the representation and behavior of 32- and 64-bit floating point numbers. IEEE 754 support provides for consistency of basic computational results among platforms that use IEEE 754. An excellent overview of the standard is presented online by Steve Hollasch at http://research.microsoft.com/~hollasch/cgindex/coding/ieeefloat.html. A heavy-duty online discussion of floating point numbers and the standard is provided by David Goldberg at http://docs.sun.com/source/806-3568/index.html.
Visual Studio 2010 Shell with Lahey's exclusive Fortran Integration.
The project is a basic building block that Visual Studio uses to create
applications. A project will normally take a set of one or more source files and
produce a compiled executable, but a project can also produce things like DLLs
or static libraries, or do other sorts of processing. All the source files
within a project are usually written in one programming language, and are
compiled with one compiler. The LF95 integration package provides several type
of projects, and allows users of previous versions of Visual Studio to automatically upgrade their native Fortran projects to VS 2010. The LF95 project facility automatically scans all source files at build time and ensures all files are built in the proper order to satisfy module dependencies.
Win32 project templates
On-line integrated help
The VS2010 integration package provides documentation that is integrated into Visual Studio help system. The comprehensive documentation covers the Fortran language, LF95 compiler usage, and Fortran-smart Visual Studio editing features:
Syntax coloring provides the ability to differentiate code elements based on color. For example, a keyword may appear in blue, comments may appear in green, while character strings might be maroon. The Fortran language allows variables and procedures to have the same names as keywords, and this can pose a problem for colorizers that do not have a strong parsing ability. Since the parser used in the Lahey colorizer is derived from a Fortran compiler, it is unlikely that is would be confused by an identifier with the same name as a keyword. The integration package allows the user to customize the colorizing scheme.
Expandable code can make the chore of navigating through sections of code easier by allowing you to collapse a region of code into a single line. This feature works at the module and procedure levels by default, but the user has the ability to add new outlining regions, or to remove existing outlining regions.
A portion of the collapsed code can be viewed by hovering the mouse over the box containing the "...":
Method tips for intrinsic functions
Parameter Info is a feature that helps the user write code by displaying information about intrinsic procedures as the user is typing. Parameter Info is currently implemented for all Fortran 95 intrinsic procedures, and Lahey extensions supported by LF95.
As a procedure invocation is typed, the open parenthesis character triggers the Parameter Info tooltip for the first argument:
As typing continues, each succeeding comma character that is typed will trigger a tooltip for the next parameter:
When a close parenthesis character is typed, the tooltip window is dismissed. The tooltip window is also dismissed whenever the cursor is moved outside of the area of the argument list.
Quick info for local and global variables
Quick Info provides the user with information about variables and intrinsic procedures by displaying an informational tooltip window when the mouse is hovered over a name. Quick Info is currently implemented for all Fortran 95 intrinsic procedures, Lahey extensions supported by LF95, and variables that are defined within the same file.
Block commenting and indenting
Block commenting is a feature that allows the user to quickly comment or uncomment selected blocks of code. Block indenting allows the user to change the indentation of a selected block of code. Both of these features work for code that is highlighted. If any portion of a line is highlighted, the feature works on the entire line. If there is no highlighted code, commenting or indenting will work on the single line where the cursor resides.
Parenthesis matching is a feature that locates a matching parenthesis and highlights the parenthesis pair. This feature can be quite useful when examining a complex statement. The following diagram shows a single multiline code statement with the matching braces highlighted with a light gray box:
Block Reformatting is a free-format source code feature that allows the user to quickly reformat the current line, selected blocks of code, or the entire document. Reformatting is done by optionally highlighting a section of code, then choosing the Edit|Advanced|Reformat Selection menu option. You may select Format Document instead of Format Selection, and the entire document will be reformatted regardless of selection area. If any portion of a line is highlighted, the feature works on the entire line. If there is no highlighted code, the single line where the cursor resides will be reformatted.
A section of code before reformatting:
Code Completion is a source code editor feature that assists rapid development by offering an alphabetical list of possible keywords, names, and code snippets that might be entered as code is typed into the editor. The list display is triggered by typing an alphabetic character at the beginning of a line, after whitespace, or after any symbol.
If another character is typed, the list will be reduced to only those items that begin with that text.
Code Snippets are a source code editor feature that assists rapid development by allowing pre-defined blocks of code to be easily inserted into the editor. Snippets are normally code that is often entered, such as IF constructs, FUNCTION definitions, and header comment blocks. Code Snippets can be inserted by selecting from the Code Completion list (press Tab after selecting), or by right-clicking and selecting "Insert Snippet...". When a Snippet is first inserted, the snippet-entry mode is activated. The names that are normally changed by the author will be highlighted fields. When the cursor is in a field, that field's text can be changed. Press Tab to move to the next field. Press Enter when finished changing the fields, thereby terminating snippet-entry mode. It is possible for a Code Snippet to have no fields and not activate the snippet-entry mode.
User-defined Collapsible Regions can make the chore of navigating through sections of source code easier by allowing you to collapse a region of code into a single line. The Fortran compiler treats these lines as comments. The region can then be collapsed by clicking on the minus symbol in the margin next to the !#region line. To expand the region, click the plus symbol in the margin.
Find All References
Find All References is a feature that allows the user to display a list of all known references to a name within all of the source code in the Solution. It works in both the source code editor window, Class View and Object Browser. Right-click on a name in a Fortran code editor window to display a list of all known references to that name within the scope of the current cursor position. Right-clicking on anything other than a name will have no effect. Right-click on a item in the Member pane of Class View or Object Browser to display a list of all known references to that name within the Solution. The list will be displayed in the Find Symbol Results window. Double-click on a line in the list to open the source code file and jump to the position of that reference.
Go To Declaration
Go To Declaration is a feature that allows you to jump to the declaration of a variable or procedure. This can be done by placing the mouse over the name you want to see the declaration for, right clicking and selecting "Go To Declaration" from the floating menu.
The edit cursor will then jump to the line that contains the declaration for the name:
Use the drop-down navigation bars above a Fortran code editor window to view or jump to a module or procedure definition within the code. The navigation bar on the left contains the Main Program and Modules defined in the source code file. Note that if a file contains subprogram(s) and no Main Program, "(MAIN)" will be displayed as a placeholder for the Main Program. The navigation bar on the right contains procedures defined in the source code file. Dimmed procedure names are out of scope for the current cursor position, but can still be selected.
Smart Indenting is a free-format source code feature that allows the editor to indent the last line entered (terminated by the Enter key) as appropriate in relation to the previous line or the beginning statement of a code block. A code block consists of any statement that has a corresponding END statement.
Building Projects and Viewing Errors
To build a Fortran project, select the "Build Solution" or "Rebuild Solution" option from the Build pull down menu. Alternatively, you can right-click on the project name in the Solution Explorer and select "Build" or "Rebuild" from the context menu that appears. The Error List window shows any build errors that occurred. Double-click on a message in the list to open the source code file and jump to the position where the error occurred. The current source code editor window will mark the location of build errors with a squiggly underline. Positioning the mouse pointer over the location of those markers will display the error in a Quick Tip.
Beginning with Visual Studio 2010, Fortran programs are debugged using Visual Studio, which hosts the FDB command line debugger. The LF95 Fortran integration package uses Visual Studio debugging interfaces to host the FDB command line debugger. This allows you to debug your Fortran program using the Visual Studio Debug menu. While debugging, you can watch the values of variables change during program execution and set breakpoints with a mouse click. Using the VS debugging interface, you can run your program, set breakpoints, step a line at a time, view the values of variables in your program in several different ways, change the values of variables, and examine stack frames while running your program. The current executable line and any breakpoints are indicated with markers in the left margin of the source code display. If needed, the program will be rebuilt, the debugger will be started and the program will begin execution. When the program breaks execution, the execution pointer is displayed at the corresponding location in source code.
To examine all local variables within the scope of the current procedure, open the Debug menu and expand the "Windows" item. Select "Locals" from the "Windows" sub menu.
To watch a variable within the scope of the current procedure, open the Debug menu and select "QuickWatch". A dialog will appear that allows you to type the name of the variable you want to watch. If the name matches a valid variable in the program, it will be added to the watch list. To view a watch window, open the Debug menu and expand the "Windows" item. Select "Watch" from the "Windows" sub menu.
While debugging, variable values are added to the intellisense "Quick Info" display, which allows values to be examined by hovering the mouse over the variable in question.
Class View and Object Browser
Class View displays the entity names defined in the application you are developing. You can open Class View from the View menu. There are two panes: an upper Objects pane and a lower Members pane. The Objects pane contains an expandable tree of names whose top-level nodes represent Projects. Expand a Project name in the Objects pane to list the Main Program and/or Modules defined within it. Variables, constants, procedures, TYPEs, INTERFACEs, and USEs for the selected Object are listed in the Members pane. Note that if a project contains subprogram(s) and no Main Program definition, a placeholder for the Main Program named "(MAIN)" will appear in the Objects pane. Right-click on an item in the Members pane to find all references of that name or to open files and navigate directly to the line where that name is defined.
The Object Browser is similar to Class View but shows more information. It also displays the names defined in the application you are developing. You can open Object Browser from the View menu. There are three panes: an Objects pane on the left, a Members pane on the upper right, and a Description pane on the lower right. If you resize the Object Browser into a single column, the Objects pane moves to the top, the Members pane to the middle, and the Description pane to the bottom. The Objects pane contains an expandable tree of names whose top-level nodes represent Projects. Expand a Project name in the Objects pane to list the Main Program and/or Modules defined within it. Variables, constants, procedures, TYPEs, INTERFACEs, and USEs for the selected Object are listed in the Members pane. Details on the item selected in the Objects pane or Members pane appear in the Description pane. Note that if a project contains subprogram(s) and no Main Program definition, a placeholder for the Main Program named "(MAIN)" will appear in the Objects pane. Right-click on an item in the Members pane to find all references to that name or to open files, and navigate directly to the line where the name is defined. You can also click on a USEd module name in the Description pane to jump to that member in Object Browser.
Automation is the ability to control Visual Studio, solutions and projects with software. It allows the user to programmatically control project creation and modification, to set project and file compilation options, and to build and execute projects.
MSBuild is Microsoft's XML-based build system. It is integrated with Visual Studio, but it can also be used on the command line. The LF95 Project facility uses MSbuild when building projects. For a comprehensive description of MSBuild, see the MSDN documentation for msbuild.exe.
Visual SourceSafe support
The Fortran integration package supports the Visual SourceSafe VCS. From Visual Studio 2008, the user with Visual SourceSafe installed will be able to easily place entire Fortran solutions under version control. The user can check Fortran files and projects in and out with Visual Studio. Note that because the Fortran project system modifies the project file in order to update dependency information, it is necessary to check out the project file before building the project.
Other Development Tools
Complementing the Windows Development Environment, LF Fortran 95 includes the Microsoft's make utility (nmake), Automake make utility; Microsoft's library manager (lib) and Lahey's Library Manager (LM) for building and working with library files; and Microsoft's linker (link).
Winteracter Starter Kit.
Use the Winteracter Starter Kit -WiSK - to create GUI-based Fortran programs, using
standard Windows controls. WiSK is a subset of the Winteracter toolset created by
Interactive Software Services, Ltd. Winteracter is a Fortran 95-callable, user-interface and
graphics development kit with versions available for Windows, Linux and Mac OS X .
Derived from Winteracter, WiSK provides a library of subroutines to manage user interface
components such as windows, menus, dialogs, mouse and keyboard. Menus and dialogs are
designed/maintained using the supplied visual resource editor, ResEdit. A manifest creation
tool enables use of the latest visual styles on Windows XP onwards. A set of graphics
primitives are also included in the WiSK library, along with source code for an emulation of
the earlier Lahey Video Graphics Library. WiSK is completed by the Application Wizard,
which provides a jump start when producing new GUI based applications.
New Features in WiSK 9.1
- Support for Windows XP/Vista/7 visual styles. Dialog controls can automatically adapt to native "look" of current platform.
- Substantially updated resource editor
- Documentation extensively updated
- Resizable dialogs
- Integer and real numeric dialog fields
- New and updated example programs
- Improved runtime error reporting
- Additional library and system interrogation functions
Click here to view/download all WiSK examples.
Fujitsu Visual Analyzer.
Visually analyze the call structure and logic flow of your Fortran and C source code. Display a detailed cross reference of all the variables in the program and where modules and commons are defined and referenced. Show C global variable definitions and references as well. VA can help you understand someone else's code, detect subtle programming errors across multiple files, and verify compliance with the Fortran 95 standard.
LF Fortran 95 beta tester Barry Santana says, "Fujitsu Visual Analyzer has been a great help in avoiding conflicts in the modifications. The help that Lahey Technical Support has provided quickly and without hassle has provided this project with a much needed shot in the arm! It has confirmed that my decision to switch to the Lahey compiler was correct. Thanks for all the help."
Fujitsu Scientific Subroutine Library 2.
The Fujitsu Scientific Subroutine Library 2 (SSL2) has been in use for years in Japan on Fujitsu mainframe and workstation hardware. SSL2 offers over 250 optimized routines in the following areas:
Matrix Storage Mode Conversion
Linear Equations and Matrix Inversion (Direct Method)
Least Squares Solution
Eigenvalues and Eigenvectors
Eigenvalues and Eigenvectors of a Real Matrix
Eigenvalues and Eigenvectors of a Complex Matrix
Eigenvalues and Eigenvectors of a Real Symmetric Matrix
Eigenvalues and Eigenvectors of a Hermitian Matrix
Eigenvalues and Eigenvectors of a Real Symmetric Band Matrix
Eigenvalues and Eigenvectors of a Real Symmetric Generalized Eigenproblem
Eigenvalues and Eigenvectors of a Real Symmetric Band Generalized Eigenproblem
Nonlinear Simultaneous Equations
Minimization of Function with a Variable
Unconstrained Minimization of Multivariable Function
Unconstrained Minimization of Sum of Squares of Functions (Nonlinear Least Squares Solution)
Nonlinear Programming (Constrained Minimization of Multivariable Function)
Interpolation and Approximation
Discrete Real Fourier Transforms
Discrete Cosine Transforms
Discrete Sine Transforms
Discrete Complex Fourier Transforms
Numerical Differentiation and Quadrature
Sine and Cosine Integrals
Normal Distribution Functions
Pseudo Random Numbers
Pseudo Random Generation
Pseudo Random Testing
Free Email Support.
Free e-mail, fax, and postal mail technical support available with LF Fortran 95.
LF Fortran 95 Specifications
||Guarantee consistency of REAL and COMPLEX calculations
||Link with optimized BLAS library
||Set default block size for OPEN statements
||Create object and/or module files without an executable
||Check substrings and array subscripts, non-common variables accessed before initialization, and mismatched procedure arguments
||Generate compiler error messages, and perform full compile and runtime checking
||Display compiler options
||Support carriage control characters in console I/O
||Generate information for use by the coverage tool
||Deallocate allocatable arrays
||Extend REAL and COMPLEX variables, arrays, constants, and functions to KIND=8
||Generate a dynamic link library
||Generate warnings for non-standard Fortran 95
||Ensure driver interprets file name as name of file and not a switch argument
||Interpret source files as Fortran 95 fixed source form
||Generate debugger information
||Specify search path for Fortran INCLUDE files
||Equivalent to including an IMPLICIT NONE statement in each program unit
||Display informational messages at compile time
||Inline user-defined procedures
||Link with optimized LAPACK library
||Avoid recognizing non-standard Lahey intrinsic procedures
||Extend all default INTEGER variables, arrays, constants, and functions to KIND=8
||Create source listings
||Specify maximum number of fatal errors allowed before stopping compilation
||Generate code compatible with other languages
||Specify default mixed language target
||Specify search path for module files
||Override default object file name
||Optimization level 0 - perform no optimization
||Optimization level 1 - perform full optimization
||-o1 plus loop and array optimizations
||Specify output file name
||Create pause after program completion
||Prevent invoked subprograms from storing into constants
||Generate prefetch optimizations
||Set default block size for OPEN statements
||Extend all double-precision REAL and COMPLEX variables, arrays, rays, constants, and functions to KIND=16
||Allocate local variables in a compiler-generated SAVE area
||Link with optimized SSL II library
||Optimize using SSE2 instructions
||Static or dynamic linkinf of Fortran runtime libraries
||Statically link with code produced by another supported language system
||Check for stack overflows
||Suppress warning messages
||Generate code optimized for Intel 80386 or 80486 processor
||Generate code optimized for Intel Pentium Pro, Pentium II, Pentium III, or Celeron processors, or generic counterparts
||Generate code optimized for Intel Pentium 4, Xeon, or generic counterparts
||Include procedure traceback and line numbers in runtime error messages
||Trap numeric data processor (NDP) exceptions at runtime
||Control loop unrolling
||Allocate local variables on heap
||Display version and owner information only
||Create a simple console-like Windows GUI application
||Generate warning messages
||Wide fixed form line length
||Create Windows application
||Create Windows Console application
||Create application that uses the Winteracter Starter Kit (WiSK)
||Generate warning messages for obsolescent Fortran
||Create cross-reference listings
||Include variables initialized to zero
||Enable flush-to-zero mode for SSE2 instructions
LF Fortran 95 System Requirements
- 1 GHz or higher, Intel or AMD processor (Pentium III or better)
- 1 GB or more RAM
- 1024x600 display (Recommended Minimum for Visual Studio)
LF Fortran v7.3 and Visual Studio 2010 can be installed onto any of the following systems:
- Windows 8 (32 and 64 bit)
- Windows 7 (32 and 64 bit)
- Windows Vista (32 and 64 bit) with Service Pack 2 (SP2) - all editions except Starter Edition
- Windows XP with Service Pack 3 (SP3)
- Windows Server 2008 R2 (x64)
- Windows Server 2008 (32 and 64 bit) with Service Pack 2 (SP2)
- Windows Server 2003 R2 (x64)
- Windows Server 2003 (32 and 64 bit) with Service Pack 2 (SP2)
Target Operating System
LF Fortran 95 applications are compatible with Microsoft Windows 8, 7, Vista, XP, 2000, NT 4.0, Me, 98, and 95.