Intel® Fortran Compilers

Performance without compromise on Windows*, Linux* and OS X*

  • Broad support for current and previous Fortran standards, plus popular extensions
  • Intel® Math Kernel Library included in suites
  • Optional Rogue Wave* IMSL* Fortran Numerical Library on Windows

Try & Buy Intel® Fortran Compiler in:

Intel® Parallel Studio XE

A complete Fortran development environment for Windows*

  • Works with Microsoft* Visual Studio* 2010, 2012 and 2013
  • Don't have Visual Studio? No problem - a Fortran development environment based on Microsoft Visual Studio 2010 Shell is included - nothing else to buy!
  • Develop, build, debug and run from the familiar Visual Studio IDE, or build and run from the command line - your choice!
  • 32-bit and 64-bit development included - no extra charge!
  • Create traditional console applications or advanced graphical interfaces with QuickWin, OpenGL* and Windows API support
  • COM (Component Object Model) and .NET interoperability provided
  • Build mixed-language applications with C++, Visual Basic*, Microsoft C# and more! (requires Microsoft Visual Studio)
  • Tens of thousands of declarations of routines, types and constants for Windows API, OpenGL, POSIX, dialogs, multi-byte character support and more!

Intel Fortran integration into Microsoft Visual Studio

  1. Fortran project and source files in Visual Studio
  2. Fortran-aware text editor with context-sensitive help, Go To Definition, templates, coloring and more
  3. Debug Fortran code with full access to Fortran types and arrays
  4. Build and debug mixed-language programs in a single Visual Studio solution
  5. Set breakpoints at Fortran source lines, with optional conditions


Broad support for current and previous Fortran standards, plus popular extensions

  • Full language Fortran 95, full Fortran 2003, plus significant Fortran 2008 features
    • Coarrays
    • DO CONCURRENT
    • 31 array dimensions (standard specifies 15)
    • NEWUNIT in OPEN
    • Much more - see release notes for details
  • Also supports FORTRAN IV (FORTRAN-66), FORTRAN 77 and Fortran 90
  • Extensive OpenMP 4.0* support
  • Source compatible with Compaq Visual Fortran* - most projects just need a rebuild

Performance without compromise

  • Industry leading performance on Intel and AMD* processors.  Take a look at the benchmarks below that were run by Polyhedron* for independent confirmation.


Geomean time in seconds - lower is better
As published 3/10/2014 at http://www.polyhedron.com

  • Extensive optimizations for the latest Intel processors, including Intel® Xeon Phi™ coprocessor
  • Take advantage of multicore, manycore and multiprocessor systems with OpenMP, automatic parallelism, DO CONCURRENT, coarrays and Intel Xeon Phi coprocessor support
  • Patented automatic CPU dispatch feature gets you code optimized for the current running processor

Intel® Math Kernel Library

  • Included in Fortran suites that adds advanced math processing
  • Vectorized and threaded for highest performance on all Intel and compatible processors
  • De facto standard APIs for simple code integration
  • Compatible with all C, C++ and Fortran compilers
  • Royalty-free, per developer licensing for low cost deployment
  • Click here for more information.

Rogue Wave* IMSL* 7 Fortran Numerical Library

  • Optional add-on to the suites that include Intel Visual Fortran compiler
  • Superior accuracy and reliability through 40 years of refinement
  • A comprehensive set of 1000+ algorithms
  • Supporting parallel processing architectures since 1990
  • Evolves easily with software and hardware upgrades
  • Click here for more information and pricing

Outstanding support

  • One year of support included with purchase – gives you access to all product updates and new versions released in the support period plus access to Intel® Premier Support
  • Active user forums for help from experienced users and Intel engineers

Works with your familiar development environment

  • Uses gcc tools, including gdb debugger
  • Link compatible with C and C++ from gcc
  • 32-bit and 64-bit compilers included – no extra charge!

Broad support for current and previous Fortran standards, plus popular extensions

  • Full language Fortran 95, Full Fortran 2003, plus significant Fortran 2008 features
    • Coarrays
    • DO CONCURRENT
    • 31 array dimensions (standard specifies 15)
    • NEWUNIT in OPEN
    • BLOCK
    • Much more - see release notes for details
  • Also supports FORTRAN IV (FORTRAN-66), FORTRAN 77 and Fortran 90
  • Extensive OpenMP 4.0* support

Performance without compromise

  • Industry leading performance on Intel and AMD processors. Take a look at the benchmarks below that were run by Polyhedron for independent confirmation.


Geomean time in seconds - lower is better
As published 3/10/2014 at http://www.polyhedron.com

  • Extensive optimizations for the latest Intel processors including Intel® Xeon Phi™ coprocessor
  • Take advantage of multicore, manycore and multiprocessor systems with OpenMP, automatic parallelism, DO CONCURRENT, coarrays and Intel Xeon Phi coprocessor support
  • Patented automatic CPU dispatch feature gets you code optimized for the current running processor

Intel® Math Kernel Library

  • Included in Fortran suites that adds advanced math processing
  • Vectorized and threaded for highest performance on all Intel and compatible processors
  • De facto standard APIs for simple code integration
  • Compatible with all C, C++ and Fortran compilers
  • Royalty-free, per developer licensing for low cost deployment
  • Click here for more information

Outstanding support

  • One year of support included with purchase – gives you access to all product updates and new versions released in the support period plus access to Intel® Premier Support
  • Active user forums for help from experienced users and Intel engineers

Works with your familiar development environment

  • Build from command line or use Xcode integration (limited feature)
  • Link compatible with C and C++ from gcc
  • 32-bit and 64-bit compilers included – no extra charge!

Broad support for current and previous Fortran standards, plus popular extensions

  • Full language Fortran 95, full Fortran 2003, plus significant Fortran 2008 features
    • DO CONCURRENT
    • 31 array dimensions (standard specifies 15)
    • NEWUNIT in OPEN
    • BLOCK
    • Much more - see release notes for details
  • Also supports FORTRAN IV (FORTRAN-66), FORTRAN 77 and Fortran 90
  • Extensive OpenMP 4.0* support

Performance without compromise

  • Industry leading performance
  • Extensive optimizations for the latest Intel processors
  • Take advantage of multicore, manycore and multiprocessor systems with OpenMP, automatic parallelism, DO CONCURRENT
  • Patented automatic CPU dispatch feature gets you code optimized for the current running processor

Intel® Math Kernel Library

  • Vectorized and threaded for highest performance on all Intel and compatible processors
  • De facto standard APIs for simple code integration
  • Compatible with all C, C++ and Fortran compilers
  • Royalty-free, per developer licensing for low cost deployment
  • Included in Intel® Fortran Composer XE
  • Click here for more information

Outstanding support

  • One year of support included with purchase – gives you access to all product updates and new versions released in the support period plus access to Intel® Premier Support
  • Active user forums for help from experienced users and Intel engineers

Videos to help you get started.

  • Introduction to Intel® Visual Fortran in the Microsoft* Visual Studio* Development Environment
  • Optimizing your application with Intel® C++ and Fortran Compilers for Windows* and Linux*

Register for future Webinars


Previously recorded Webinars:

  • Update Now: What’s New in Intel® Compilers and Libraries
  • An Introduction to Intel® Visual Fortran Development on Intel® Xeon Phi™ coprocessor
  • OpenMP 4.0 for SIMD and Affinity Features with Intel® Xeon® Processors and Intel® Xeon Phi™ Coprocessor
  • Learn to be an Intel® Visual Fortran Power User
  • Optimizing and Compilation for Intel® Xeon Phi™ Coprocessor

Featured Articles

No se encontró contenido

More Tech Articles

Scheduling for 1-4 Threads Per Core Using Compiler Option -qopt-threads-per-core
Por Ronald W Green (Intel)Publicado en 10/16/20130
Compiler Methodology for Intel® MIC Architecture Scheduling for 1-4 Threads Per Core Using Compiler Option -qopt-threads-per-core This option is a hint or suggestion to the compiler about the number of hardware threads per core that MAY be used for an application. This hint enables the compiler...
Application Analysis for Intel® MIC Architecture Suitability
Por AmandaS (Intel)Publicado en 10/16/20130
Compiler Methodology for Intel® MIC Architecture Application Analysis for Intel® MIC Architecture Suitability The Intel® Many Integrated Core Architecture (Intel® MIC Architecture) provides a product family optimized to deliver performance for highly parallel applications or highly parallel ker...
Preparing for the Intel® Many Integrated Core Architecture
Por AmandaS (Intel)Publicado en 10/16/20132
Compiler Methodology for Intel® MIC Architecture Preparing for the Intel® Many Integrated Core Architecture The Intel® Many Integrated Core Architecture (Intel® MIC Architecture) provides a product family optimized to deliver performance for highly parallel applications or highly parallel kerne...
Programming and Compiling for Intel® Many Integrated Core Architecture
Por AmandaS (Intel)Publicado en 10/16/20131
Compiler Methodology for Intel® MIC Architecture This methodology enables you to determine your application's suitability for performance gains using Intel® Many Integrated Core Architecture (Intel® MIC Architecture).
Suscribirse a Artículos de la Zona para desarrolladores Intel

Supplemental Documentation

No se encontró contenido
Suscribirse a Artículos de la Zona para desarrolladores Intel

You can reply to any of the forum topics below by clicking on the title. Please do not include private information such as your email address or product serial number in your posts. If you need to share private information with an Intel employee, they can start a private thread for you.

New topic    Search within this forum     Subscribe to this forum


Error #8055: The procedure has a ... VALUE... Required explicit interface is missing from original source.
Por daninraleigh2
I just downloaded and installed the latest update(w_fcompxe_2015.2.179) and am now getting an error that I did not get when using the version from October of 2012(w_fcompxe_novsshell_2013.1.119). I uninstalled the latest and went back to October 2012 version and do not get the error. Then installed the latest and get the error again. It appears that something has changed. Do I need to declare the pass by value differently now? Below is the error I get with the latest version of the Intel Fortran compiler: Error    3     error #8055: The procedure has a dummy argument that has the ALLOCATABLE, ASYNCHRONOUS, OPTIONAL, POINTER, TARGET, VALUE or VOLATILE attribute. Required explicit interface is missing from original source.   [DATE_ADDR] Here is the code that calls the function and then the function below: CHARACTER (LEN=11) :: v_bcdmdhm,tmp_bcdmdhm tmp_bcdmdhm = v_bcdmdhm( date_addr ) !Get 2 BYTES (4 DIGITS) from Binary Data and return as integer*4 FUNCTION v_bcdmdhm( addr ) ...
How small can we go?
Por Steve Lionel (Intel)6
Those of you who follow my @DoctorFortran Twitter feed have seen this already, but for the rest of you...  I have acquired five MinnowboardMAXes - small single-board computers with dual-core Atom processors and 2GB of RAM. My primary goal for these is to form a Linux cluster and demonstrate coarrays on them, but I took one of them and loaded Windows 10 and Visual Fortran on it. Works fine, if not the speediest thing in the world. It doesn't help that the "system disk" is a 32GB MicroSD card.
Auto update of file version number in a *.rc resource file
Por Greg Thorwald3
Hello, I have a .rc resource file in a Fortran DLL project where I set information like the version number.  Is there a way to automatically increment part of the file version number with each build?  I currently manually edit the file version number, which is not onerous, but automation would be welcome.  It looks like the .rc file is a text file that could perhaps be modified by a script, unless that would corrupt it.  Thanks for any advice. Regards, Greg
ICE with 15.0.2
Por IanH4
Oh the trouble I had - when compiling the attached the compiler went bad, which made me all sad.  If it got fixed I would be glad, so help me, before I go mad. >ifort /c /check:all /warn:all /standard-semantics /stand slippery-little-so-and-so.f90 Intel(R) Visual Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 15.0.2.179 Build 20150121 Copyright (C) 1985-2015 Intel Corporation. All rights reserved. slippery-little-so-and-so.f90(38): warning #6178: The return value of this FUNCTION has not been defined. [WHAT] FUNCTION ts_What() RESULT(what) ----------------------------^ ... slippery-little-so-and-so.f90(76): remark #7712: This variable has not been used. [NAMES] SUBROUTINE ParseDataComponentDefStmt(decl_spec, attrs, names) ---------------------------------------------------------^ fortcom: Fatal: There has been an internal compiler error (C0000005). compilation aborted for slippery-little-so-and-so.f90 (code 1) 
MKL 11.2 Install Failure - Fortran Composer XE 2015 / VS 2010 Shell
Por Scott Graham7
I recently attempted to upgrade my Fortran compiler to the Fortran Composer XE 2015 edition released on 2/5/2015.  The Fortran upgrade appears to have gone OK. However, when installing the MKL libraries I get an error that the debugger extension requires Visual Studio 2012 or 2013, and the install window for the MKL libraries places a red X on the install of "Intel MKL core libraries for Intel (c) 64" and "Intel MKL core libraries for IA32".  Does the new version of MKL require Visual Studio 2012 or 2013?  Is there a work around to get this to work on my VS 2010 shell that came with the Intel Fortran compiler? Thanks !
Array Initialization Error when mixing different integer types.
Por Michael B.5
Code: PROGRAM main   USE ISO_C_BINDING     IMPLICIT NONE   INTEGER, PARAMETER :: DIM0 = 7   INTEGER, PARAMETER :: DIM1 = 4   INTEGER, PARAMETER :: num_flags = 4   INTEGER(kind=8), PARAMETER :: DIM0a = 7   INTEGER(kind=8), PARAMETER :: DIM1a = 4     INTEGER, DIMENSION(1:3) :: dim_qf_data =(/DIM0,4,num_flags/)   INTEGER(kind=8), DIMENSION(1:2) :: dims = (/DIM0a,DIM1a/) ! #1   INTEGER(kind=8), DIMENSION(1:2) :: dims = (/DIM0,DIM1/) ! #2   print*,dim_qf_data    print*,dims END PROGRAM main When I use #1 it prints correctly: 7,4,4 7,4   But when I use #2 it prints dim_qf_data's second array value wrong: 7,0,4 7,4   For Intel 14.0 it was correct for both. It also works correctly on Mac and Linux with Intel 15.0 (and 14.0).   Computer system env. attached.          
Visual Studio IDE issue: blank members drop-down for a module with parameterized derived type and a type with a bound procedure.
Por FortranFan4
With Visual Studio 2013 and Intel Fortran integration using compiler 2015, update 2, the members drop-down for the source window in the IDE shows up empty for the simple module code shown below.  Hopefully the problem is reproducible and it can be directed for a resolution. module m implicit none type :: t(n) integer, len :: n real :: x(n) end type type, public :: foo private real, allocatable :: m_x(:) type(t(:)), allocatable :: m_t contains private procedure, pass(this), public :: init end type foo contains pure subroutine init(this, x, irc) !.. Argument list class(foo), intent(inout) :: this real, intent(in) :: x(:) integer, intent(inout) :: irc !.. Local variables integer :: size_x !.. irc = 0 size_x = size(x) if (size_x > 0) then allocate( t(size_x) :: this%m_t, stat=irc ) if (irc /= 0) return this%m_t%x ...
Another ICE with parameterized derived type
Por FortranFan3
Please check this out: module m implicit none type :: t(n) integer, len :: n real :: x(n) end type type, public :: foo private real, allocatable :: m_x(:) type(t(:)), allocatable :: m_t contains private procedure, pass(this), public :: init end type foo contains pure subroutine init(this, x, irc) !.. Argument list class(foo), intent(inout) :: this real, intent(in) :: x(:) integer, intent(inout) :: irc !.. Local variables integer :: size_x !.. irc = 0 size_x = size(x) if (size_x > 0) then allocate( t(size_x) :: this%m_t, stat=irc ) if (irc /= 0) return this%m_t%x = sqrt(x) this%m_x = x else irc = 1 end if !.. return end subroutine init end module m program p use m, only : foo !.. implicit none !.. type(foo) :: a integer :: erc call a%in...
Suscribirse a Foros

You can reply to any of the forum topics below by clicking on the title. Please do not include private information such as your email address or product serial number in your posts. If you need to share private information with an Intel employee, they can start a private thread for you.

New topic    Search within this forum     Subscribe to this forum


Have input variables from header file be recognized as initialized variables
Por Solal A.4
Hey, I am currently debugging my code for a runtime error (invalid pointer) but the compiler does not give me valuable information for locating this error even with -traceback. I am therefore make use of all the debug flags I found online with the hope that it may solve the problem: FLAGS = -O2 -stand f03 -std -check all -traceback -warn all -fstack-protector -assume protect_parens -implicitnone   Using these flags, I actually get a lot more error than the one I had to begin with. One of them is about a variable name which does not have a type: visc.f90(29): error #6404: This name does not have a type, and must have an explicit type.   [BC_UY]         CALL FxxSBP_t (d2udy(i,:,k),u(i,:,k),h(2),nptsy, BC_UY) The variable BC_UY is defined in a header file and loaded in the code with the #INCLUDE statement. Is there a way I can load in the variable from the header files so that the compiler initializes it correctly?
Customizing Makefile for the programm using Fortran Compiler.
Por Konstantin C.3
Hi! I'm trying to define the makefile for compiling the programm in Linux that uses Fortran Compiler. In the programm manual it is written that it requires FORTRAN90 compiler and MPI. I've installed Intel Parallel Sdudio 2015 and openMPI. The target template in the makefile looks like this: # Generic target template #===================================================================== uknown_platform:     $(MAKE) LD="path to FORTRAN90 Linker-loaDer" \     LDFLAGS="appropriate flags for LD (MPI libraries)" \     FC="path to FORTRAN90 compiler" \     FCFLAGS="appropriate flags for FC (MPI include)" \     EX=$(EX) BINROOT=$(BINROOT) $(TYPE) I have Parallel Studio installed in /opt/intel.  All the pathes are added to bashrc file PATH=$PATH:/opt/intel/bin LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib (the pass to the openMPI libraries) PATH=$PATH:/opt/intel/impi_latest/bin64 LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/intel/impi_latest/lib64 When runing the makefile for stantart t...
How to enforce inlining ?
Por flying_hermes6
Hi, My code involves a derived-type variable (denoted 'Object' hereafter) holding another derived-type variable as a component (denoted 'SubObject'). The SubObject has a type-bound procedure for computing some quantity, let say Q. The Object also has a procedure for computing Q, but the actual computation is delegated to the SubObject component. Here is simple example: Module SubObject_Module implicit none private public :: SubObject_Type Type :: SubObject_Type contains procedure :: Compute => Compute_SubObj End Type contains Pure Subroutine Compute_SubObj( This, Inp, Out ) class(SubObject_Type) ,intent(in) :: This integer ,intent(in) :: Inp integer ,intent(out) :: Out Out = Inp * 2 End Subroutine End Module Module Object_Module use SubObject_Module ,only: SubObject_Type implicit none private public :: Object_Type Type ...
"Stack trace terminated abnormally": what does this mean?
Por MR9
Hi, running a code compiled with -check all I see various warnings concerning the creation of some temporaries (I know about them and I am fine with them) and somehow interspersed in the ouput various lines saying Stack trace terminated abnormally. What does this mean? Notice that I do see a traceback for the warnings, but this line has no traceback. I am using "Intel(R) Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 15.0 Build 20141023" Thank you, Marco
optimization help/vectorization/SIMD questions
Por Izaak Beekman11
Hi, Consider the following code snippet:  do i = 1, size(rhs,dim=2) if (n == biggest_int) exit !Overflow! n1 = n n = n + 1 n1on = real(n1,WP)/real(n,WP) ! Add SIMD dir? !!!!DIR$ SIMD PRIVATE(p,k) do concurrent (j=1:size(lhs)) ! I'm nervous about p and k getting stepped on delta(j) = rhs(j,i) - local_res(j)%M(1) local_res(j)%M(1) = local_res(j)%M(1) + delta(j)/real(n,WP) !DIR$ LOOP COUNT (1,2,3,4,5) do p = local_res(j)%p,2,-1 !iterate backwards because new M4 depends on old M3,M2 etc. sum(j) = 0 !DIR$ LOOP COUNT (0,1,2,3,4) do k = 1,p-2 sum(j) = sum(j) + & local_res(j)%binkp(k,p)*((-delta(j)/n)**k)*n1on*local_res(j)%M(p-k) end do local_res(j)%M(p) = n1on*local_res(j)%M(p) + sum(j) + & ((delta(j)/n)**p)*(n1**p + n1*((-1)**p))/n end do local_res(j)%...
Non-scalar pass-object dummy arguments
Por flying_hermes3
Hi, I am trying to use type-bound procedures (TBP) with non-scalar pass-object dummy arguments. Although not valid from the standard (C461: "The passed-object dummy argument shall be a scalar, nonpointer, nonallocatable dummy data object..."), it seems to be supported by ifort version 14.0.4 (the version I'm using here) as shown by the following code: Module MyModule implicit none Type :: MyType integer :: Val contains procedure :: ScaProc procedure :: VecProc End Type contains Subroutine ScaProc( This, Inp, Out ) class(MyType) ,intent(in) :: This integer ,intent(in) :: Inp integer ,intent(out) :: Out Out = Inp + This%Val End Subroutine Subroutine VecProc( Those, Inp, Out ) class(MyType) ,dimension(:) ,intent(in) :: Those integer ,intent(in) :: Inp integer ...
Is fstack-protector-all supported on MIC?
Por Mark M.5
I'm debugging a crash in my Fortran code, and would like to try stack protection. Is fstack-protector-all supported on the MIC platform?  When I build with -mic -fstack-protector-all the executable crashes because it can't find the libssp.so.0 library.  Is a MIC version of that library supposed to be included with my compiler?  I'm using ifort 14.0.2.   Thank you for your help.
Difference in allocating array in subroutine make a code works or breaks
Por quarkz4
Hi, I am running a mpi CFD code in my sch's cluster using 100 cpu. Due to my program's structure, this is the max cpu I can use. At the same time, due to the number of grids using in my code, I am reaching the available memory limit. The code ran and hang at a spot. After debugging, I found that it hangs in one of the subroutines. In this subroutines, I have to update the values of different variables across all cpu using mpi. There are some local array which I need to create. If I declare them using: subroutine mpi_var_... real(8) :: var_ksta(row_num*size_x*size_y), ... ...  end subroutine  The code hangs. However, if I do this: subroutine mpi_var_... real(8), allocatable :: var_ksta(:) ... allocate (var_ksta(row_num*size_x*size_y) ... deallocate (var_ksta, STAT=status(1)) end subroutine The code works. So how different is memory allocated in these 2 situations? If I am not tied down by memory limit, is the 1st subroutine faster or the same as the 2nd one (with allocation / dealloc...
Suscribirse a Foros