# T to Z

This section describes language features that start with T, U, V, W, X, Y, or Z.

Parent topic: A to Z Reference

- TAN
  Elemental Intrinsic Function (Generic): Produces the tangent of an argument.
- TAND
  Elemental Intrinsic Function (Generic): Produces the tangent of an argument.
- TANH
  Elemental Intrinsic Function (Generic): Produces a hyperbolic tangent.
- TARGET
  OpenMP* Fortran Compiler Directive: Creates a device data environment and executes the construct on that device. This feature is only available for ifx.
- TARGET DATA
  OpenMP* Fortran Compiler Directive: Maps variables to a device data environment for the extent of the region. This feature is only available for ifx.
- TARGET Statement
  Statement and Attribute: Specifies that an object can become the target of a pointer (it can be pointed to).
- TARGET ENTER DATA
  OpenMP* Fortran Compiler Directive: Specifies that variables are mapped to a device data environment. This feature is only available for ifx.
- TARGET EXIT DATA
  OpenMP* Fortran Compiler Directive: Specifies that variables are unmapped from a device data environment. This feature is only available for ifx.
- TARGET PARALLEL
  OpenMP* Fortran Compiler Directive: Creates a device data environment in a parallel region and executes the construct on that device.
- TARGET PARALLEL DO
  OpenMP* Fortran Compiler Directive: Provides an abbreviated way to specify a TARGET directive containing a PARALLEL DO directive and no other statements.
- TARGET PARALLEL DO SIMD
  OpenMP* Fortran Compiler Directive: Specifies a TARGET construct that contains a PARALLEL DO SIMD construct and no other statement.
- TARGET PARALLEL LOOP
  OpenMP* Fortran Compiler Directive: Specifies a shortcut for specifying a parallel loop inside a TARGET construct that contains no other statements than the parallel loop. This feature is only available for ifx.
- TARGET SIMD
  OpenMP* Fortran Compiler Directive: Specifies a TARGET construct that contains a SIMD construct and no other statement.
- TARGET TEAMS
  OpenMP* Fortran Compiler Directive: Creates a device data environment and executes the construct on the same device. It also creates a league of thread teams with the primary thread in each team executing the structured block.
- TARGET TEAMS DISTRIBUTE
  OpenMP* Fortran Compiler Directive: Creates a device data environment and executes the construct on the same device. It also specifies that loop iterations will be distributed among the primary threads of all thread teams in a league created by a TEAMS construct.
- TARGET TEAMS DISTRIBUTE PARALLEL DO
  OpenMP* Fortran Compiler Directive: Creates a device data environment and then executes the construct on that device. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams created by a TEAMS construct.
- TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD
  OpenMP* Fortran Compiler Directive: Creates a device data environment and then executes the construct on that device. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams created by a TEAMS construct. The loop will be distributed across the teams, which will be executed concurrently using SIMD instructions.
- TARGET TEAMS DISTRIBUTE SIMD
  OpenMP* Fortran Compiler Directive: Creates a device data environment and executes the construct on the same device. It also specifies that loop iterations will be distributed among the primary threads of all thread teams in a league created by a TEAMS construct. It will be executed concurrently using SIMD instructions.
- TARGET TEAMS LOOP
  OpenMP* Fortran Compiler Directive: Specifies a shortcut for specifying a TEAMS LOOP construct inside a TEAMS construct that contains no other statements. This feature is only available for ifx.
- TARGET UPDATE
  OpenMP* Fortran Compiler Directive: Makes the list items in the device data environment consistent with their corresponding original list items. This feature is only available for ifx.
- TARGET VARIANT DISPATCH
  Offloading Compiler Directive: Conditionally calls a procedure offload variant if the device is free; otherwise, executes the procedure on the host. This directive is an Intel® language extension. This feature is only available for ifx.
- TASK
  OpenMP* Fortran Compiler Directive: Defines a task region.
- TASK_REDUCTION
  Specifies a reduction among tasks. The TASK_REDUCTION clause is a reduction scoping clause.
- TASKGROUP
  OpenMP* Fortran Compiler Directive: Specifies a wait for the completion of all child tasks of the current task and all of their descendant tasks.
- TASKLOOP
  OpenMP* Fortran Compiler Directive: Specifies that the iterations of one or more associated DO loops should be executed in parallel using OpenMP* tasks. The iterations are distributed across tasks that are created by the construct and scheduled to be executed.
- TASKLOOP SIMD
  OpenMP* Fortran Compiler Directive: Specifies a loop that can be executed concurrently using SIMD instructions and that those iterations will also be executed in parallel using OpenMP* tasks.
- TASKWAIT
  OpenMP* Fortran Compiler Directive: Specifies a wait on the completion of child tasks generated since the beginning of the current task.
- TASKYIELD
  OpenMP* Fortran Compiler Directive: Specifies that the current task can be suspended at this point in favor of execution of a different task.
- TEAM_NUMBER
  Transformational Intrinsic Function (Generic): Returns the team number of the specified team.
- TEAMS
  OpenMP* Fortran Compiler Directive: Creates a league of thread teams to execute a structured block in the primary thread of each team. This feature is only available for ifx.
- TEAMS DISTRIBUTE
  OpenMP* Fortran Compiler Directive: Creates a league of thread teams to execute a structured block in the primary thread of each team. It also specifies that loop iterations will be distributed among the primary threads of all thread teams in a league created by a TEAMS construct.
- TEAMS DISTRIBUTE PARALLEL DO
  OpenMP* Fortran Compiler Directive: Creates a league of thread teams to execute a structured block in the primary thread of each team. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams.
- TEAMS DISTRIBUTE PARALLEL DO SIMD
  OpenMP* Fortran Compiler Directive: Creates a league of thread teams to execute a structured block in the primary thread of each team. It also specifies a loop that can be executed in parallel by multiple threads that are members of multiple teams. The loop will be distributed across the primary threads of the teams region, which will be executed concurrently using SIMD instructions.
- TEAMS DISTRIBUTE SIMD
  OpenMP* Fortran Compiler Directive: Creates a league of thread teams to execute the structured block in the primary thread of each team. It also specifies a loop that will be distributed across the primary threads of the teams region. The loop will be executed concurrently using SIMD instructions.
- TEAMS LOOP
  OpenMP* Fortran Compiler Directive: Specifies a shortcut for specifying a LOOP construct inside a TEAMS construct. This feature is only available for ifx.
- THIS_IMAGE
  Transformational Intrinsic Function (Generic): Returns the image index of the invoking image on the current or specified team, or the cosubscripts for the executing image on the current or specified team.
- THREADPRIVATE
  OpenMP* Fortran Compiler Directive: Specifies named common blocks and certain variables to be private (local) to each thread; they are global within the thread.
- TIME Intrinsic Procedure
  Intrinsic Subroutine (Generic): Returns the current time as set within the system. TIME can be used as an intrinsic subroutine or as a portability routine. It is an intrinsic procedure unless you specify USE IFPORT. Intrinsic subroutines cannot be passed as actual arguments.
- TIME Portability Routine
  Portability Function or Subroutine: The function returns the system time, in seconds, since 00:00:00 Greenwich mean time, January 1, 1970. TIME can be used as a portability function or subroutine, or as an intrinsic procedure. It is an intrinsic procedure unless you specify USE IFPORT.
- TIMEF
  Portability Function: Returns the number of seconds since the first time it is called, or zero.
- TINY
  Inquiry Intrinsic Function (Generic): Returns the smallest number in the model representing the same type and kind parameters as the argument.
- TRACEBACKQQ
  Run-Time Subroutine: Provides traceback information. Uses the Intel® Fortran run-time library traceback facility to generate a stack trace showing the program call stack as it appeared at the time of the call to TRACEBACKQQ( ).
- TRAILZ
  Elemental Intrinsic Function (Specific): Returns the number of trailing zero bits in an integer.
- TRANSFER
  Transformational Intrinsic Function (Generic): Converts the bit pattern of the first argument according to the type and kind parameters of the second argument.
- TRANSPOSE
  Transformational Intrinsic Function (Generic): Transposes an array of rank two.
- TRIM
  Transformational Intrinsic Function (Generic): Returns the argument with trailing blanks removed.
- TTYNAM
  Portability Subroutine: Specifies a terminal device name.
- Type Declarations
  Statement: Explicitly specifies the properties of data objects or functions.
- TYPE Statement (Derived Types)
  Statement: Declares a variable to be of derived type. It specifies the name of the user-defined type and the types of its components.
- UBOUND
  Inquiry Intrinsic Function (Generic): Returns the upper bounds for all dimensions of an array, or the upper bound for a specified dimension.
- UCOBOUND
  Inquiry Intrinsic Function (Generic): Returns the upper cobounds of a coarray.
- UNDEFINE
  Statement: Removes a defined symbol.
- UNION and END UNION
  Statements: Define a data area that can be shared intermittently during program execution by one or more fields or groups of fields. A union declaration must be within a structure declaration.
- UNLINK
  Portability Function: Deletes the file given by path.
- UNPACK
  Transformational Intrinsic Function (Generic): Takes elements from a rank-one array and unpacks them into another (possibly larger) array under the control of a mask.
- UNPACKTIMEQQ
  Portability Subroutine: Unpacks a packed time and date value into its component parts.
- UNROLL (OpenMP*)
  OpenMP* Fortran Compiler Directive: Partially or fully unrolls a DO loop. This feature is only available for ifx.
- UNROLL and NOUNROLL General Directives
  General Compiler Directive: Tells the compiler's optimizer how many times to unroll a DO loop or disables the unrolling of a DO loop. These directives can only be applied to iterative DO loops.
- UNROLL_AND_JAM and NOUNROLL_AND_JAM
  General Compiler Directive: Hints to the compiler to enable or disable loop unrolling and jamming. These directives can only be applied to iterative DO loops.
- UNTIED Clause
  Parallel Directive Clause: Specifies that the task is never tied to the thread that started its execution.
- USE
  Statement: Gives a program unit accessibility to public entities in a module.
- USE_DEVICE_PTR Clause
  Parallel Directive Clause: Tells the construct to use a device pointer currently in the device data environment.
- %VAL
  Built-in Function: Changes the form of an actual argument. Passes the argument as an immediate value.
- VALUE
  Statement and Attribute: Specifies a type of argument association for a dummy argument.
- VECREMAINDER Clause
  General Directive Clause: Allows the compiler to vectorize (or not to vectorize) any peel or remainder loops when the original loop is vectorized.
- VECTOR and NOVECTOR
  General Compiler Directive: Overrides default heuristics for vectorization of DO loops. It can also affect certain optimizations.
- VERIFY
  Elemental Intrinsic Function (Generic): Verifies that a set of characters contains all the characters in a string by identifying the first character in the string that is not in the set.
- VIRTUAL
  Statement: Has the same form and effect as the DIMENSION statement. It is included for compatibility with PDP-11 FORTRAN.
- VOLATILE
  Statement and Attribute: Specifies that the value of an object is entirely unpredictable, based on information local to the current program unit. It prevents objects from being optimized during compilation.
- WAIT
  Statement: Performs a wait operation for a specified pending asynchronous data transfer operation. It takes one of the following forms:
- WHERE
  Statement and Construct: Lets you use masked array assignment, which performs an array operation on selected elements. This kind of assignment applies a logical test to an array on an element-by-element basis.
- WORKSHARE
  OpenMP* Fortran Compiler Directive: Divides the work of executing a block of statements or constructs into separate units. It also distributes the work of executing the units to threads of the team so each unit is only executed once.
- WRITE Statement
  Statement: Transfers output data to external sequential, direct-access, or internal records.
- XOR
  Elemental Intrinsic Function (Generic): An alternative name for intrinsic function IEOR.
- ZEXT
  Elemental Intrinsic Function (Generic): Extends an argument with zeros. This function is used primarily for bit-oriented operations. It cannot be passed as an actual argument.