This is a computer translation of the original content. It is provided for general information only and should not be relied upon as complete or accurate.

Sorry, we can't translate this content right now, please try again later.

This document provides a summary of new and changed product features and includes notes about features and problems not described in the product documentation.

Please see the licenses included in the distribution as well as the Disclaimer and Legal Information section of these release notes for details. Please see the following links for information on this release of the Intel® Visual Fortran Compiler 17.0.

To use command-line tools only to build IA-32[5] architecture applications, one of:

Microsoft Visual Studio Express 2015 for Windows Desktop*

Microsoft Visual Studio Express 2013 for Windows Desktop*

Microsoft Visual Studio Express 2012 for Windows Desktop*

To use command-line tools only to build Intel® 64 architecture applications, one of:

Microsoft Visual Studio Express 2015 for Windows Desktop*

Microsoft Visual Studio Express 2013 for Windows Desktop*

Microsoft Visual Studio Express 2012 for Windows Desktop*

Microsoft Windows Software Development Kit for Windows 8*

To read the on-disk documentation, Adobe Reader* 7.0 or later

Notes:

Intel® Visual Fortran development environment based on Microsoft Visual Studio 2013* Shell is included with Academic and Commercial licenses for Intel® Parallel Studio XE Composer Edition for Fortran Windows*. It is not included with Evaluation licenses or the "free tools" license obtained through the free software program for students and educators. This development environment provides everything necessary to edit, build and debug Fortran applications. Some features of the full Visual Studio product are not included, such as:

To use the Intel® Visual Fortran Compiler with Microsoft Visual Studio 2013* Shell, it is necessary to install the Microsoft Windows Software Development Kit (SDK) for Windows 8.1*. This article explains how.

If you install Intel® Visual Fortran development environment based on Microsoft Visual Studio 2013* Shell, Microsoft Visual Studio Shell will detect whether your machine contains Microsoft components that are needed for Microsoft Visual Studio Shell to run, such as the .NET Framework, and automatically download and install them over the Internet if they are not present on your system.

The default for Intel® Visual Fortran is to build IA-32 architecture applications that require a processor supporting the Intel® SSE2 instructions. A compiler option is available to generate code that will run on any IA-32 architecture processor. Note, however, that applications calling Intel® MKL require a processor supporting the Intel® SSE2 instructions.

Applications can be run on the same Windows versions as specified above for development. Applications may also run on non-embedded 32-bit versions of Microsoft Windows earlier than Windows 7, though Intel does not test these for compatibility. Your application may depend on a Windows API routine not present in older versions of Windows. You are responsible for testing application compatibility. You may need to copy certain run-time DLLs onto the target system to run your application.

To use the Intel® Visual Fortran Compiler with Microsoft Visual Studio 2015*, it is necessary to install the 'Common Tools for Visual C++ 2015' component from Visual Studio. This article explains how.

To use the Intel® Visual Fortran Compiler with Microsoft Visual Studio 2017*, it is necessary to install the 'Desktop development with C++' component from Visual Studio. This article explains how.

Intel® Manycore Platform Software Stack (Intel® MPSS)

The Intel® Manycore Platform Software Stack (Intel® MPSS) may be installed before or after installing the Intel® Visual Fortran Compiler, if you will be developing applications that use Intel® Xeon™ Phi coprocessors.

It is recommend that the latest version of Intel® MPSS be used. It is available from the Intel® Software Development Products Registration Center at http://registrationcenter.intel.com as part of your Intel® Parallel Studio XE for Windows* registration.

Refer to the Intel® MPSS documentation for the necessary steps to install the user space and kernel drivers.

How to use the Intel® Visual Fortran Compiler

The Getting Started Guide at <install-dir>\IntelSWTools\documentation_2017\en\ps2017\getstart_comp_wf.htm contains information on how to use the Intel® Visual Fortran Compiler from the command line and from Microsoft Visual Studio*.

If on Windows Server 2012 you find that you cannot display help or documentation from within Internet Explorer 10, modifying a security setting for Microsoft Internet Explorer usually corrects the problem. From Tools > Internet Options > Security, add “about:internet” to the list of trusted sites. Optionally, you can remove “about:internet” from the list of trusted sites after you finish viewing the documentation.

Documentation Viewing Issue with Microsoft Edge* and Japanese Version of Microsoft Windows 10*

When viewing Intel compiler documentation with the Microsoft Edge* browser on a Japanese version of Microsoft Windows 10*, the upper left corner [Content][Index][Search] buttons do not function properly. Clicking on any of the buttons results in a blank screen.

The issue will be fixed in a future release. To workaround the issue, use Internet Explorer to view the Intel compiler documentation. To set your default browser to Internet Explorer, Google search "how to make Internet Explorer default browser on Windows 10".

Multi-pane documents do not display correctly in the Visual Studio* internal browser

The Visual Studio* internal browser default mode may cause multi-pane documents do not display correctly. The table of contents appears in the left pane, but the right pane does not display any content. The alternative is to access the same documentation from the Visual Studio* Help menu.

Intel-provided Debug Solutions

Japanese Language Support

Intel® compilers optionally provide support for Japanese language users when the combined English-Japanese product is installed. Error messages, visual development environment dialogs and some documentation are provided in Japanese in addition to English. By default, the language of error messages and dialogs matches that of your operating system language selection. Japanese-language documentation can be found in the ja subdirectory for documentation.

Japanese language support is not provided with every update of the product.

Compatibility

In general, object code and modules compiled with earlier versions of Intel Fortran Compiler (8.0 and later) may be used in a build with version 17.0. Exceptions include:

Sources that use the CLASS keyword to declare polymorphic variables and which were built with a compiler version earlier than 12.0 must be recompiled.

Objects built with the multi-file interprocedural optimization (/Qipo) option must be recompiled.

Objects that use the REAL(16) , REAL*16, COMPLEX(16) or COMPLEX*32 datatypes and which were compiled with versions earlier than 12.0 must be recompiled.

Objects built for the Intel® 64 architecture with a compiler version earlier than 10.0 and that have module variables must be recompiled. If non-Fortran sources reference these variables, the external names may need to be changed to remove an incorrect leading underscore.

Modules that specified an ATTRIBUTES ALIGN directive outside of a derived type declaration and were compiled with versions earlier than 11.0 must be recompiled. The compiler will notify you if this issue is encountered.

Modules that specified an ATTRIBUTES ALIGN directive inside a derived type declaration cannot be used by compilers older than 13.0.1.

The implementation of the Fortran 2008 submodules feature required extensive changes to the internal format of binary .mod files. Therefore module files created by the version 16.0 Fortran compiler cannot be used with version 15.0 or older Fortran compilers.

Stack Alignment Change for REAL(16) and COMPLEX(16) Datatypes (12.0)

In previous releases, when a REAL(16) or COMPLEX(16) (REAL*16 or COMPLEX*32) item was passed by value, the stack address was aligned at 4 bytes. For improved performance, compiler versions 12.0 and later align such items at 16 bytes and expect received arguments to be aligned on 16-byte boundaries.

This change primarily affects compiler-generated calls to library routines that do computations on REAL(16) values, including intrinsics. If you have code compiled with earlier versions and link it with the version 13 libraries, or have an application linked to the shared version of the Intel run-time libraries, it may give incorrect results.

In order to avoid errors, you must recompile all Fortran sources that use the REAL(16) and COMPLEX(16) datatypes.

Static Form of the Intel® OpenMP* Library is No Longer Provided

The static form of the Intel® OpenMP* library, libiomp5mt.lib, is no longer provided, and the /Qopenmp-link:static command line option is no longer supported. Please replace all references to libiomp5mt.lib with libiomp5md.lib, the DLL import library. This change also implies that applications using OpenMP will need to have the Intel® compiler redistributables installed if deployed on a system where an Intel® compiler is not also present. See Redistributable Libraries for Intel® Parallel Studio XE for more information.

Fortran Expression Evaluator

Fortran Expression Evaluator (FEE) is a plug-in for Microsoft Visual Studio* that is installed with Intel® Visual Fortran Compiler. It extends the standard debugger in Microsoft Visual Studio* IDE by handling Fortran expressions. There is no other change in usability.

New and Changed Compiler Features

Some language features may not yet be described in the compiler documentation. Please refer to the Fortran 2008 Standard (PDF) and the proposed draft Fortran 2015 Standard (PDF) if necessary.

Features from Fortran 2008

Type statement for intrinsic types

Pointer initialization

Implied-shape array

Extend EXIT statement to more construct names

Support BIND(C) in internal procedures

Change of Default in Intrinsic Assignment to Allocatable Arrays (17.0)

In previous releases, the compiler's default for intrinsic assignment to allocatable arrays was to assume that the array being assigned to was already allocated to the same shape as the value. In order to get the Fortran 2003 behavior of automatically (re)allocating the array if the shapes did not match you were required to specify the /assume:realloc_lhs compiler option (included in /standard-semantics.)

In version 17.0 of the compiler, the default has changed to match the Fortran 2003 standard so that allocatable arrays are automatically (re)allocated on intrinsic assignment as needed. This may have a small impact on performance. If you want to revert to the older behavior, specify /assume:norealloc_lhs or the new /nostandard-realloc-lhs compiler option.

Changes in Behavior of Mixed Logical/Numeric Operations (17.0)

The Fortran standard prohibits assignments and operations that mix logical and numeric (integer/real/complex) data types. As an extension to the standard, Intel Fortran permits this mixing, but the rules for how it works were not well documented and were inconsistently implemented depending on the context.

As of version 17.0, the compiler’s implementation of mixed logical-numeric operations has changed to be consistent and well-specified. However, in some cases the new behavior is different from what previous versions implemented and may change results in programs that assumed that the previous behavior was correct.

The version 17.0 behavior is as follows:

If a logical value is used in a numeric context, true values convert to integer -1 or +1, depending on the setting of the “fpscomp logicals” compiler option; false values convert to integer zero.

If a numeric value is used in a logical context, it is first converted to integer if necessary. The setting of the compiler “fpscomp logicals” option determines how the integer value is interpreted. When “nologicals” is in effect, odd values are true and even values are false. When “logicals” is in effect, non-zero values are true and zero values are false.

If a numeric value is assigned to a logical variable, the value is converted to .TRUE. or .FALSE. according to the setting of “fpscomp logicals” and the new logical value assigned. In some cases in previous versions, the binary value might have been copied directly without conversion.

If a logical value is assigned to a numeric variable, it is first converted to integer as described above and then the normal rules of intrinsic assignment are carried out.

Note that the Intel Fortran compiler default is “fpscomp nologicals”, but that the “standard-semantics” option sets “fpscomp logicals”.

If you want to know if your program is affected by this extension, build with standards warnings enabled (/stand). If you wish to revert to the old behavior, specify /assume:old_logical_assign.

Changes in Default Offload Treatment of Local Scalars with OpenMP* 4.5

The addition of support for the OpenMP* 4.5 clause DEFAULTMAP (TOFROM:SCALAR) changed the default treatment of local scalar variables. In the previous release local scalars were offloaded by default. In 17.0, local scalars are not mapped and instead have an implicit attribute of FIRSTPRIVATE. Offload of local scalars in 17.0 requires using DEFAULTMAP (TOFROM:SCALAR). See the Intel® Fortran Compiler User’s Guide for more details.

OpenMP* monitor thread

As of version 17.0.1, the OpenMP* monitor thread (i.e. helper thread) is not created.

Features from OpenMP*

The following directives, clauses and procedures, from OpenMP 4.0 and OpenMP 4.5, are now supported by the compiler.

For more information, see the compiler documentation or the link to the OpenMP Specification above.

Directives from OpenMP 4.5:

TARGET ENTER DATA

TARGET EXIT DATA

TASKLOOP

Clauses:

DEPEND on OMP TARGET and OMP TARGET UPDATE directives

NOWAIT on OMP TARGET and OMP TARGET UPDATE directives

SIMDLEN on OMP SIMD directive

SIMD on OMP ORDERED directive

PROCESSOR(cpuid) on OMP DECLARE SIMD (proc-name) directive

DEFAULTMAP (TOFROM:SCALAR) on OMP TARGET

Added processor clause to OMP DECLARE SIMD

The Intel® Visual Fortran Compiler 17.0 includes an extension to OMP DECLARE SIMD which will allow programmers to use YMM/ZMM registers with OpenMP SIMD. The clause PROCESSOR(cpuid) will tell the compiler to create a vector version of a routine for the specified processor. See the Intel® Fortran Compiler User’s Guide for more details.

SIMD and NONMONOTONIC modifiers for !$OMP DO SCHEDULE clause

The Intel® Fortran Compiler 17.0 includes new SIMD and NONMONOTONIC modifiers extensions to OMP DO SCHEDULE clause to enhance user control of how iterations of the DO loop are divided among threads of the team. See the Intel® Fortran Compiler User’s Guide for more details.

Support for taskloop and do across loop as described in the OpenMP* 4.5

The Intel® Visual Fortran Compiler 17.0 adds support for new loop construct for parallelizing for/do loops. “taskloop” is similar to cilkfor loop, enables the dynamic divide-and-conquer loop partitioning under Intel tasking execution model. “doacross” enables the parallelization of loops with loop-carried dependency.

New Intel® Xeon Phi™ offload features

OpenMP* 4.5 clause changes

for combined or composite constructs, the if clause now supports a directive name modifier:

if([directive-name-modifier :] scalar-logical-expression) the if clause only applies to the semantics of the construct named by directive-name-modifier if specified; otherwise it applies to all constructs to which an if clause can apply. Example: !$omp target parallel for if(target : do_offload_compute)

use_device_ptr(list) clause now implemented for !$omp target data

is_device_ptr(list) clause now implemented for !$omp target

Support for combined target constructs:

!$omp target parallel

!$omp target parallel for

!$omp target simd

!$omp target parallel for simd

New modifiers for omp declare simd linear clause

The linear clause on omp declare simd declarative directive is extended with new modifiers:

linear (linear-list [ : linear-step] )
where linear-list is one of the following:list
where modifier (list)modifier is one of the following:refvaluval

All list items must be dummy arguments of the function that will be invoked concurrently on each SIMD lane.

If no modifier is specified or if the val or uval modifier is specified, the value of each list item on each lane corresponds to the value of the list item upon entry to the function plus the logical number of the lane times linear-step.

If the uval modifier is specified, each invocation uses the same storage location for each SIMD lane; this storage location is updated with the final value of the logically last lane.

If the ref modifier is specified, the storage location of each list item on each lane corresponds to an array at the storage location upon entry to the function indexed
by the logical number of the lane times linear-step.

New and Changed Directives

ATTRIBUTES code_align(n)

As of compiler version 17.0, the ATTRIBUTES code_align(n) directive may be specified to request code alignment for a function. 'n' specifies the number of bytes for the minimum alignment boundary. It must be a power of 2 between 1 and 4096, such as 1, 2, 4, 8, 16, 32, 64, 128, and so on. n = 1 does no alignment. n must appear.

New /[no]standard-realloc-lhs Compiler Option

New /Qopt-zmm-usage option

You can tune the zmm code generation done by the compiler with the new additional option /Qopt-zmm-usage:low|high. The argument value of low provides a smooth transition experience from Intel® Advanced Vector Extensions 2 (Intel® AVX2) ISA to Intel® Advanced Vector Extensions 512 (Intel® AVX-512) ISA on a Skylake server microarchitecture target, such as for enterprise applications. Tuning for ZMM instruction use via explicit vector syntax such as #pragma omp simd simdlen() is recommended. The argument value of high is recommended for applications, such as HPC codes, that are bounded by vector computation to achieve more compute per instruction through use of the wider vector operations. The default value is low for Skylake server microarchitecture-family compilation targets and high for combined compilation targets.

Visual Studio Integration Changes

Microsoft Visual Studio 2017* Support

Integration support for Intel® Fortran compiler added for Microsoft Visual Studio 2017*. Refer to System Requirements for additional information.

Improved source code navigation in Microsoft Visual Studio IDE

The Visual Studio IDE now provides a “tree-view” for easy module/procedure navigation (similar to the Solution explorer view). For more information, see the compiler documentation.

Changes in Online Help format in Microsoft Visual Studio*

The online help format is now browser-based. When you view Intel documentation from the Microsoft Visual Studio Help menu, or when you view context-sensitive help using F1 or a help button in a dialog box or other GUI element, your default browser shows the corresponding help topic. You may encounter some minor functionality issues depending on your default browser. Known issues include:

When Set Help Preference is set to Launch in Browser and you hit F1 in Tools>Options>F# Tools or Tools>Options>Intellitrace, the browser appears twice.

Chrome*: When arriving at a topic from Search or Index, the Table of Contents (TOC) does not sync, nor does the Sync TOC link work.

Firefox*: The TOC loses context easily. Search is case sensitive

Safari*: Response on Windows is slow.

New Fortran Project from Existing Code

In Visual Studio you can now select File > New > Fortran Project From Existing Code. This will create a new Fortran project with sources added from a folder you select. The project wizard will allow you to customize the project type and platform.

IA-32 host installation is not supported

Microsoft Visual Studio 2010* not supported

Known Issues

Command-Line Diagnostic Issue for Filenames with Japanese Characters

The filename in compiler diagnostics for filenames containing Japanese characters may be displayed incorrectly when compiled within a Windows command shell using the native Intel® 64 architecture compiler. It is not a problem when using Visual Studio or when using the Intel® 64 architecture cross-compiler or IA-32 architecture compiler.

Debugging mixed language programs with Fortran does not work

To enable debugging Fortran code called from a .NET managed code application in Visual Studio 2012 or later, unset the following configuration:

The following uses of length type parameters in parameterized derived types (PDTs) are not yet fully implemented:

PDT parameter constants with length type parameters

%RE and %IM are not yet implemented

Intel Compiler Help Documentation fails to launch from IDE when installed on Japanese version of Windows

In some cases, custom installations of Intel(R) Parallel Studio XE 2016 on Japanese versions of Windows will cause Intel compiler Help documentation to fail to launch from the Microsoft Visual Studio* IDE. Details describing this issue can be found here.

For Intel Fortran Compiler IDE integration with Microsoft Visual Studio 2015 Update 1 there is an issue with the link to the build log in the output window. Only the portion before the first space character in the path is included to the link as shown in the following image:

The workaround is to copy the link from the output window and open it using a web browser.

It is possible to experience several internal errors during a build attempt for the Debug configuration under Visual Studio where it is common to have /debug-parameter and /debug options enabled simultaneously.

Under Visual Studio, using only minimal /debug information (i.e. Properties > Fortran > Debugging > Information set to Line Numbers Only) with any setting for /debug-parameters (see the property setting in #1 above).

On the compiler command-line, removing all occurrences of the /debug-parameters from compiler command-line or within application build scripts when using /debug:full

On the compiler command-line, using /debug:minimal with any setting for /debug-parameters on the compiler command-line or within application build scripts.

warning #31001: The dll for reading and writing the pdb (for example, mspdb110.dll) could not be found on your path.

When using Microsoft Visual Studio Express*, compilation for IA-32 with -debug (General > Debug Information Format) enabled may result the warning:

warning #31001: The dll for reading and writing the pdb (for example, mspdb110.dll) could not be found on your path. This is usually a configuration error. Compilation will continue using /Z7 instead of /Zi, but expect a similar error when you link your program.

The warning is expected and occurs because a 64 bit Windows* applications (i.e. the Intel® Fortran compiler) must use 64 bit dlls (https://msdn.microsoft.com/en-us/library/windows/desktop/aa384231(v=vs.85).aspx); however, Microsoft Visual Studio Express* only provides a 32 bit version of mspdb*.dll. The missing 64 bit version leads to the warning. This is a warning-level diagnostic that does not impede successfully building an executable; however, debug information requested is embedded into the object (.obj) file for use with the debugger. No .pdb file is produced by the compiler when /Z7 is enabled.

Certain uses of OMP THREADPRIVATE with COMMON block name not diagnosed per OpenMP* 4.5 rules

The OpenMP* 4.5 rules states that if a threadprivate directive specifying a common block name appears in one program unit, then such a directive must also appear in every other program unit that contains a COMMON statement specifying the same name. It must appear after the last such COMMON statement in the program unit. The Intel Fortran compiler does not properly diagnose this.

For example, the following program does not conform to the OpenMP* 4.5 specification and ifort does not diagnose and issue an error for the COMMON statements following the OMP THREADPRIVATE statement according to the rule above.

PROGRAM ex1
COMMON /common_blk1/x
!$OMP THREADPRIVATE(/common_blk1/)

COMMON /common_blk1/y
COMMON /common_blk1/z

END PROGRAM

Intel® Visual Fortran Module Wizard module files not added to project

When using Microsoft Visual Studio 2017*, module files generated by the Intel® Visual Fortran Module Wizard are not added to the project automatically. You must manually add the module files to the project after they are generated, click Project-> Add Existing Item and specify location where the file was generated.

Project Categories not Localized on Japanese system

On Japanese system, under Microsoft Visual Studio 2017*, the Fortran project categories are not localized in New Project wizard.

"rc.exe not found" when building Fortran Projects

With only the Microsoft Windows SDK* (10.0.15063.0) installed Fortran projects may fail to build with an "rc.exe not found" error.

To avoid this issue, please install the previous version of Microsoft Windows 10 SDK* (for example 10.0.14393) or copy the content of the following folders as indicated:

Microsoft Visual Studio 2012*, 2013, 2015, and 2017 Notes

Microsoft Visual Studio 2010 brought several changes that primarily affect building of mixed-language applications where the main program is in C or C++. These changes were carried forward into Visual Studio 2012/2013/2015.

In previous releases, one used the Tools > Options > Projects and Solutions > VC++ Directories dialog to make the Intel Fortran LIB folder available to C/C++ projects. In Visual Studio 2010 and later, the method of doing this is very different.

In Visual Studio, with a solution open that contains a C++ project, select View > Property Manager. If you do not see Property Manager under the View menu, you will find it under View > Additional Windows. The Property Manager window will appear. Note that this is not Properties Window or Properties Pages.

Click on the triangles or + signs to expand the property tree under the Debug|Win32 configuration

Double click on Microsoft.Cpp.Win32.user

Select VC++ Directories

Click in the field to the right of "Library Directories"

Click the triangle that appears to the right and select <Edit...>

Click the New Line button or press Ctrl-Insert

In the new field that appears, type:

$(IFORT_COMPILER17)\compiler\lib\ia32

Click OK, OK

In the Visual Studio toolbar, select File > Save All

If you will be building Intel® 64 (x64) configurations:

Back in the Property Manager, expand the Debug|x64 configuration

Double click on Microsoft.Cpp.x64.user

Select VC++ Directories

Click in the field to the right of "Library Directories"

Click the triangle that appears to the right and select <Edit...>

Click the New Line button or press Ctrl-Insert

In the new field that appears, type:

$(IFORT_COMPILER17)\compiler\lib\intel64

Click OK, OK

In the Visual Studio toolbar, select File > Save All

Click on the Solution Explorer tab, or press Ctrl-Alt-L, to make it visible again.

If you do not see the Microsoft.Cpp.x64.user property page listed for the x64 configuration, right click on Debug|x64 and select Add Existing property Sheet. Browse to the location which contains the MsBuild 4.0 property pages. On Windows XP, this is typically:

You may need to enable viewing of hidden files and folders to see these paths.

Select Microsoft.Cpp.x64.user.props and click Open. Now follow the steps above.

Adjusting Project Dependencies

If you are converting a project from an earlier version of Visual Studio and had established Project Dependencies, these are converted to References by Visual Studio 2012/2013/2015. A Fortran project that is referenced by a C/C++ project will prevent the C/C++ project from building, with an MSB4075 error. To solve this:

Right click on the C/C++ project and select References.

If any Fortran project is shown as a reference, click Remove Reference. Repeat this for all Fortran projects shown as a reference. Click OK.

Repeat the above steps for any other C/C++ project that has dependencies.

Unlike earlier versions of Visual Studio, Visual Studio 2012 does not automatically link in the output library of dependent projects, so you will need to add those libraries explicitly to the parent project under Linker > Additional Dependencies. You can use the Visual Studio macros $(ConfigurationName) and $(PlatformName) as required to qualify the path. For example:

..\FLIB\$(ConfigurationName)\FLIB.lib

Where $(ConfigurationName) will expand to Release or Debug, as appropriate. Similarly, $(PlatformName) will expand to Win32 or x64 as appropriate.

If on Windows Server 2012* and Windows Server* 2008 you find that you cannot display help or documentation from within Visual Studio 2012, correcting a security setting for Microsoft Internet Explorer* usually corrects the problem. From Tools > Internet Options > Security, change the settings for Internet Zone to allow “MIME Sniffing” and “Active Scripting”.

"No apps are installed to open this type of link (file)" when viewing Parallel Studio XE documentation under Microsoft Visual Studio* IDE

When no browser is registered as the handler for .htm* files, viewing documentation under the IDE via Help > Intel Compilers and Libraries can result in an error popup indicating "No apps are installed to open this type of link (file)".

To resolve this issue, select the preferred browser for the file type .htm under either Control Panel > View by: large (or small) icons > Default programs > Associate a file type or protocol with a program / Set your default programs -or- Settings > System > Default Apps > Choose Default Apps by File type.

Microsoft Visual C++ 2012 Redistributable* (x86) is not installed.
Installation can continue; however, some components of this installation may not be fully functional without it.
Install the redistributable from here (https://www.microsoft.com/en-us/download/details.aspx?id=30679).

The download noted in the installation message is only required when using a Microsoft Visual Studio* version earlier than Microsoft Visual Studio* 2017 with the Intel® Parallel Studio XE 2017 release.

Additionally, the download at the cited web-address is no longer available; therefore, to obtain this download user must now join the Visual Studio Dev Essentials (free) program and search for "Visual C++ Redistributable for Microsoft Visual Studio 2012 Update 4" in the Downloads section.

Fortran 2008 and Fortran 2015 Feature Summary

The Intel® Fortran Compiler also supports many features from the Fortran 2008 standard as well as Features from the proposed draft Fortran 2015 standard. Additional features will be supported in future releases. Fortran 2008 features supported by the current version include:

An OPTIONAL dummy argument that does not have the ALLOCATABLE or POINTER attribute, and which corresponds to an actual argument that: has the ALLOCATABLE attribute and is not allocated, or has the POINTER attribute and is disassociated, or is a reference to the NULL() intrinsic function, is considered not present

A dummy argument that is a procedure pointer may be associated with an actual argument that is a valid target for the dummy pointer, or is a reference to the intrinsic function NULL. If the actual argument is not a pointer, the dummy argument shall have the INTENT(IN) attribute.

BLOCK construct

intrinsic subroutine EXECUTE_COMMAND_LINE

Submodules

IMPURE

Type statement for intrinsic types

Pointer initialization

Implied-shape array

Extend EXIT statement to more construct names

Support BIND(C) in internal procedures

Proposed draft Fortran 2015 features supported by the current version include:

Support for all features from “Technical Specification 29113 Further Interoperability with C”, planned for inclusion in Fortran 2015. These include:

Assumed type (TYPE(*))

Assumed rank (DIMENSION(..))

relaxed restrictions on interoperable dummy arguments

ISO_Fortran_binding.H C include file for use by C code manipulating “C descriptors” used by Fortran

Disclaimer and Legal Information

Optimization Notice

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.

Notice revision #20110804

INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL(R) PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR.

Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.

The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.

Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.