What's New in IDL 8.9

New Features
Updates
Library Updates
See Also

For links to What's New information for other releases, go to See Also.

New Features

New Licensing Engine

This version includes a new licensing engine. The same activation codes you used to activate your previous version of IDL can also be used to activate your new license. If you still have your legacy license installed, the License Administrator will be able to detect it and migrate your license.

ASDF (Advanced Scientific Data Format) File Support

IDL now supports reading and writing files in the ASDF (Advanced Scientific Data Format) file format. The ASDF_Parse function is used to read ASDF files into IDL, while ASDF_Write is used for creating ASDF files. The IDL ASDF reader/writer provides a straightforward, simple way to access and modify data using simple array notation via an ASDF_File class. The new ASDF_NDArray class allows for easy translation of ASDF/Python ndarray arrays to/from IDL arrays. For example, to create a simple ASDF file, then read it back into IDL:

a = ASDF_File('mydata', randomu(seed, 100, 50))

ASDF_Write, 'myfile.asdf', a

af = ASDF_Parse('myfile.asdf')

help, af

help, af['mydata']

help, af['mydata', 'data']

IDL prints:

AF              ASDF_FILE  <ID=28  NELEMENTS=3>  TAG='!core/asdf-1.1.0' GLOBAL_TAGS=1

<Expression>    ASDF_NDARRAY  <ID=27>  float32 [50,100] internal

<Expression>    FLOAT     = Array[100, 50]

Complex Number Constants

You can now use "i" and "j" as suffixes to create complex numbers. For example:

help, 1 - 2i, 3.14i, 1 + 2d-20i

<Expression>    COMPLEX   = (      1.00000, -    2.00000)

<Expression>    COMPLEX   = (      0.00000,      3.14000)

<Expression>    DCOMPLEX  = (       1.0000000,   2.0000000e-20)

Creating complex numbers this way is significantly faster than using the COMPLEX or DCOMPLEX functions. See Defining and Using Constants for details.

You can also input complex numbers from files or strings using this notation:

IDL> num = 0i ; create a complex zero

IDL> reads, '1+2i', num ; complex number cannot contain spaces

IDL> help, num

NUM               COMPLEX   = (      1.00000,      2.00000)

Binary, Octal, and Hexadecimal Constants

You can now use the special prefixes 0b, 0o, and 0x to construct binary, octal, and hexadecimal number constants:

help, 0b101110111100, 0o777, 0xFA62, BigInteger('0xFFFFFF')

<Expression>    INT       =     3004

<Expression>    INT       =      511

<Expression>    LONG      =        64098

<Expression>    BIGINTEGER <ID=7 LENGTH=24 bits> = 16777215

These prefixes can be combined with the usual integer suffixes (b, s, l, u) to construct integers of different types.

The prefixes can also be used when reading input from files or strings.

IDL> num = 0L

IDL> reads, "0x2000", num

IDL> help, num

NUM             LONG      =     8192

IDL> reads, '0o777', num

IDL> help, num

NUM             LONG      =        511

IDL> reads, '0b101110111100', num

IDL> help, num

NUM             LONG      =         3004

To print out these numbers or convert them to strings, use %x, %o, or %b:

IDL> print, 8192, 511, 3004, format='%x %o %b'

2000 777 101110111100

See Defining and Using Constants for details.

Gabor Transform Filter

The new GABOR_KERNEL and GABOR_FILTER functions can be used to perform a complex Gabor filter on two-dimensional arrays. The Gabor filter consists of a sinusoidal wave in a particular orientation, with a Gaussian envelope that limits the effect to a localized region around each point in the image. The filter is useful for edge detection and texture analysis.

Gabor Demo Application

The new gabor_demo_app procedure (in the examples/doc/image subdirectory) can be used to explore different Gabor parameters for the Gabor filter function. You can open different image files, tweak the parameter values, and then see the new kernel function on the left and the filter results on the right superimposed on the original image.

Template Literal Strings

You can now create template literal strings using backtick characters. These template literal strings can contain IDL expressions (evaluated at runtime) and can span multiple lines, with all whitespace and line breaks preserved in the final string (hence the word "literal"). The strings can also contain special characters such as line breaks.

For example:

a = [1, 2, 3, 4, 5]

result = `There are ${total(a gt 2, /int)} matches\nin the array ${a}.`

print, result

IDL prints:

There are 3 matches

in the array [1,2,3,4,5].

For more details see Template Literal Strings.

FLOAT64 and IDL3 Compile Options

The new FLOAT64 compile option indicates that floating-point constants will default to the 64-bit DOUBLE type rather than the usual 32-bit FLOAT type. Floating-point constants with an "e" exponent will remain as 32-bit floats. The new IDL3 compile option is a shortcut for the compile options DEFINT32, FLOAT64, LOGICAL_PREDICATE, and STRICTARR. For more details see COMPILE_OPT.

YAML (YAML Ain't Markup Language) Support

IDL can now parse YAML strings and files using YAML_PARSE. You can also convert IDL hash, list, and other datatypes to YAML using YAML_SERIALIZE.

Updates

Array Concatenation

You can now concatenate IDL arrays using up to 8 nesting levels of brackets (the previous limit was 3 levels). For example:

IDL> a = fltarr(2,2,2,2,2,2,2,2)

IDL> b = a

IDL> help, [a, b]

<Expression>    FLOAT     = Array[4, 2, 2, 2, 2, 2, 2, 2]

IDL> help, [[[[a]]], [[[b]]]]

<Expression>    FLOAT     = Array[2, 2, 2, 4, 2, 2, 2, 2]

IDL> help, [[[[[[[[a]]]]]]], [[[[[[[b]]]]]]]]

<Expression>    FLOAT     = Array[2, 2, 2, 2, 2, 2, 2, 4]

See Creating Arrays for details.

CONVOL EDGE_REFLECT Keyword

The CONVOL function has a new EDGE_REFLECT keyword, which will treat values at the array edge as reflected. This is similar to the EDGE_MIRROR keyword except the point at the very edge is not repeated. For example, if the array values are represented by "abcdefg" then the effective array will be "gfedcb|abcdefg|fedcba".

ISA UNSIGNED Keyword

The ISA function has a new UNSIGNED keyword, which will return true for unsigned integer variables, and false otherwise.

JSON_SERIALIZE PRETTY Keyword

The JSON_SERIALIZE function has a new PRETTY keyword, which will output the JSON in a "pretty" format with line breaks and indentation using spaces.

Python Bridge Installation

The process for installing the IDL-to-Python and Python-to-IDL bridges has been streamlined and made more robust. See Python Bridge for details.

Support Removed for 32-bit IDL

Support for running IDL in 32-bit mode has been removed. This also includes removing COM Object-Import (IDLcomIDispatch) and DXF file format (IDLffDXF) support.

Library Updates

The 3rd party libraries listed below have been updated to these versions:

CDF 3.8.1
- New CDF_READCDF routine
- New CDF_READVARIABLE routine
curl 7.88.1
ffmpeg 4.4.3
jackson-json-processor 2.14.2
libtiff 4.5.0
libxml2 2.10.3
openssl 1.1.1t
sqlite 3.41.2
x11-xpm 3.5.15
zlib 1.2.13

The following 3rd party libraries have been added:

rapidyaml 0.5.0

The following 3rd party libraries have been removed:

IDL Python Bridge support for Python 3.7

Product	IDL

Version	9.0