Modify output figures interactively using the tools in the upper right corner of each axes. These tools appear when you select or hover over the axes. For more information, see Modify Output Figures.

You can build an equation interactively in live scripts by selecting from a graphical display of symbols and structures. To insert a new equation, go to the Live Editor tab and in the Insert section, click Equation. For more information, see Insert Equations into Live Scripts.

For quick formatting in live scripts, you can use a combination of keyboard shortcuts and character sequences. For more information, including a list of supported sequences, see Autoformatting.

Prevent typographical errors by automatically renaming multiple references to a function or variable within a live script. When you rename such a function or variable, a tooltip opens if there is more than one reference to that variable or function in the file. Press Shift + Enter to rename all instances of the function or variable.

Drag selected code from a live script to and from another application, maintaining syntax highlighting and font characteristics.

The Live Editor now displays output in live scripts as it is created, instead of when the execution of a section is complete.

When displaying output, the Command Window now adds a header that includes the class, size, and shape of a variable. For example:

A = rand(4, 6, 'single')

A =
  4×6 single matrix
    0.8147    0.6324    0.9575    0.9572    0.4218    0.6557
    0.9058    0.0975    0.9649    0.4854    0.9157    0.0357
    0.1270    0.2785    0.1576    0.8003    0.7922    0.8491
    0.9134    0.5469    0.9706    0.1419    0.9595    0.9340

The Command Window also displays array dimensions using a standardized format and an improved layout for integer arrays.

Download and install MathWorks^® product trials directly from MATLAB^® using the Add-On Explorer. To open the Add-On Explorer, go to the Home tab and click the Add-Ons icon.

When you package a toolbox, MATLAB detects live script examples. Then, when someone installs your toolbox, the examples appear in the MATLAB Help browser.

Integrating your toolbox documentation into the MATLAB Help browser is easier with automatically generated template files. To display your toolbox documentation under Supplemental Software in the Help browser, edit the info.xml and helptoc.xml template files.

MATLAB automatically detects JAR files to include on the dynamic path, and you can manage these files in the Package a Toolbox dialog box.

For more information, see Create and Share Toolboxes.

MATLAB now saves preferences to your user Application Support folder on Mac OS X systems. The location of the user Application Support folder is ~/Library/Application Support.

Browse examples across MathWorks products or search for examples using the search box and search filters. To access examples online, go to http://www.mathworks.com/help/examples.html. To access examples in MATLAB, go to the Home tab and click Help > Examples.

Click the Open Script or Open Live Script button in an example to open it in MATLAB. MATLAB copies the example file and all dependent files to the folder userpath/Examples/examplefilename, where examplefilename is the name of the example file. The userpath is the path returned by the userpath command. MATLAB then changes the current folder to the new folder. You can run the example as is or edit it before running.

MATLAB scripts, including live scripts, can contain code to define local functions. Local functions in scripts are useful for experimenting with code within a single file, as well as writing reusable code that can easily be added, modified, and deleted. For more information, see Add Functions to Scripts.

Note:   If your script contains local functions, you cannot run code sections (also known as code cells) individually. The Run Section and Run and Advance buttons are disabled. To run the script, type the saved script name in the Command Window or click Run. You can run sections individually in live scripts containing local functions.

string arrays provide storage of text data and a set of functions for manipulating text. For example, functions such as contains find text in strings. The split and join functions split and join strings in string arrays. You can compare strings with relational operators such as ==, and sort them with the sort function.

For more information, see Characters and Strings.

The timetable data container is a table that associates a time with each row. Like the table container, the timetable data container stores column-oriented data variables that have different data types and sizes, as long as the data variables have the same number of rows. To create timetables from workspace variables or from tables, use the timetable or table2timetable functions. You can resample or aggregate data in timetables with the retime and synchronize functions. You also can use any table function with timetables.

For more information, see Timetables.

You can create a subscripting variable with the timerange function and use that variable to subscript into a timetable data container.

You can access all table variables of a specified data type with the vartype function. For example, if T is a table, then S = vartype('numeric'); Tnum = T(:,S) returns Tnum as a table that contains only the numeric variables from T.

You can access all table or timetable variables with compatible types using the Variables property. For example, if T is a 5-by-2 table with two numeric variables, then T.Variables returns a 5-by-2 numeric matrix. T.Variables is equivalent to the T{:,:} syntax.

Search through folders and subfolders on the path recursively using wildcards in the path name. For more information, see dir.

Note:   The * character is now always treated as a wildcard, even on file systems that support * in file names.

When you add a folder to the MATLAB search path using a relative path, MATLAB now adds the absolute path of the folder to the search path. In previous versions of MATLAB, MATLAB added the relative path of the folder, and the path was re-resolved after every change to the current folder.

Compatibility Considerations

If your MATLAB search path contains relative paths to folders, and you rely on the automatic re-resolving of the paths when changing folders, you must update your search path. Use the Set Path dialog box or the addpath or path functions to add the absolute path of folders to the search path. For more information, see Change Folders on the Search Path.

MATLAB now adds the folders specified by the MATLABPATH environment variable to the MATLAB search path on Windows^® platforms. This action was previously only done on UNIX^® platforms. For more information, see Set the MATLABPATH Environment Variable.

As of R2016b, the userpath function now only returns the first folder on the search path. In previous versions of MATLAB, userpath returned the first folder on the search path, appended with the folders listed in the MATLABPATH environment variable for UNIX platforms.

Compatibility Considerations

If you have scripts or functions that rely on the userpath function to return both the first folder on the search path and the paths listed in the MATLABPATH environment variable, then you must update your code. Use the userpath function to receive only the userpath folder, or use the path function to receive the full MATLAB search path.

You can specify the 'forceCellOutput' argument to force the regexp and regexpi functions to return output arguments in a cell array. For example, regexp(str,expression) returns the indices of matches as a numeric array when str is a character vector or a string scalar, but regexp(str,expression,'forceCellOutput') returns the same numeric array within a cell.

You can specify the 'flexible' argument when calling regexptranslate to replace matching patterns in text with an escaped regular expression that you specify. The syntax regexptranslate('flexible',str,expression) replaces the same text as regexprep(str,expression,regexptranslate('escape',expression)).

As of R2016b, private functions are visible only to other functions or scripts that are in the folder immediately above the private subfolder (the parent folder). In previous versions of MATLAB, private functions were visible to scripts outside the parent folder if they were called by functions inside the parent folder.

Compatibility Considerations

If you have a function that calls a script outside the parent folder and that script calls a private function, your code might result in an error or change of behavior. If both the function that calls the script and the script that calls the private function are inside the parent folder, then there is no change in behavior.

If the function that calls the script and the script that calls the private function are in different folders:

• A change in behavior might occur if the script finds a different function with the same name as the private function.

• An error occurs if the script doesn't find any function with a name that matches the private function name.

Place scripts that need access to private functions to the folder immediately above the private subfolder.

The error message identifier MATLAB:datatypes:valueOutsideValidRange has changed.

Compatibility Considerations

If you have scripts or functions that use the MATLAB:datatypes:valueOutsideValidRange error message identifier, you must update the code to use one or more of the new identifiers listed here. Typically, you might use error message identifiers in code that uses a try/catch statement and performs an action based on a specific error identifier.

• MATLAB:datatypes:OutsideRangeFiniteGreater0

• MATLAB:datatypes:OutsideRangeIntegerGreater0

• MATLAB:datatypes:OutsideRangeNaN0to1

• MATLAB:datatypes:OutsideRangeValidNumber

• MATLAB:datatypes:OutsideRange0to1

Implicit expansion is a generalization of scalar expansion. With scalar expansion, a scalar expands to be the same size as another array to facilitate element-wise operations. With implicit expansion, the element-wise operators and functions listed here can implicitly expand their inputs to be the same size, as long as the arrays have compatible sizes. Two arrays have compatible sizes if, for every dimension, the dimension sizes of the inputs are either the same or one of them is 1. See Compatible Array Sizes for Basic Operations and Array vs. Matrix Operations for more information.

• Element-wise arithmetic operators — +, -, .*, .^, ./, .\

• Relational operators — <, <=, >, >=, ==, ~=

• Logical operators — &, |, xor

• Bit-wise functions — bitand, bitor, bitxor

• Elementary math functions — max, min, mod, rem, hypot, atan2, atan2d

For example, you can calculate the mean of each column in a matrix A, and then subtract the vector of mean values from each column with A - mean(A).

Previously, this functionality was available via the bsxfun function. It is now recommended that you replace most uses of bsxfun with direct calls to the functions and operators that support implicit expansion. Compared to using bsxfun, implicit expansion offers faster speed, better memory usage, and improved readability of code.

Graph objects created using either graph or digraph support these functions:

• isomorphism — Compute graph isomorphism equivalence relation between two graphs.

• isisomorphic — Determine if two graphs are isomorphic.

Graph objects created using graph support these functions:

• biconncomp — Compute biconnected components of undirected graph.

• bctree — Compute block-cut tree of undirected graph.

Graph objects created using digraph support these functions:

• condensation — Represent each strongly connected component in a directed graph using a single node.

The GraphPlot object returned by plotting a graph or digraph now contains a ZData property. If ZData is nonempty, then it specifies z-coordinates for the graph nodes.

Additionally, new layout methods are available for 'force3' and 'subspace3', which automatically calculate values for XData, YData, and ZData to display the graph in three dimensions.

The flipedge function reverses the direction of directed edges in a graph.

The conv2 function performs faster when using the syntax conv2(u,v,A), where u and v are vectors and A is a matrix.

To plot datetime or duration data, you can use these functions.

Also, you can use the new datetime and duration ruler objects to customize the axes. Access the datetime or duration ruler object through the axes object. For example:

d = duration(1,30:33,0);
y = [3 5 2 3];
plot(d,y)
ax = gca;
ax.XAxis

ans = 

  DurationRuler with properties:

             Limits: [01:29:55    01:33:04]
         TickValues: [01:30:00    01:30:30    01:31:00    01:31:30    01:32:00    01:32:29    01:33:00]
    TickLabelFormat: 'hh:mm:ss'

  Show all properties

For a list of object properties, see Datetime Ruler Properties and Duration Ruler Properties.

Compatibility Considerations

When plotting datetime or duration data, consider these changes:

• The xlim, ylim, zlim, and axis functions no longer accept double values to set the limits for an axis with datetime or duration values.

• The axis function no longer supports setting the axis limits for axes with mixed data types (numeric, datetime, or duration). Use the xlim, ylim, and zlim functions instead.

• The XLim, YLim, ZLim, XTick, YTick, and ZTick properties of the axes object now contain datetime or duration values instead of double values. To change the limits or tick values, specify datetime or duration values instead of double values.

• The XData, YData, and ZData properties now contain datetime or duration values instead of double values. To change the data values, specify datetime or duration values instead of double values.

• Combining plots that mix different data types along a single axis results in an error. When combining plots, use only one data type per axis.

To create scatter plots in polar coordinates, use the polarscatter function. Similarly, you can create histograms in polar coordinates using the polarhistogram function. The polarhistogram function supersedes the rose function.

To plot implicit functions of the form f(x,y) = 0, use the fimplicit function. To plot implicit functions of the form f(x,y,z) = 0, use the fimplicit3 function.

You can customize the appearance of the tick values and labels along each axis using tick formatting functions. Use the x-axis, y-axis, and z-axis versions when plotting in Cartesian coordinates. Use the r-axis and theta-axis versions when plotting in polar coordinates.

This table lists the new functions.

To plot both vertical and horizontal error bars, use the errorbar function. Also, you can control the width of the caps at each end of the error bars by setting the CapSize property of the errorbar object.

x = 1:10;
y = sin(x);
err = std(y)*ones(size(x));
e = errorbar(x,y,err,'horizontal')
e.CapSize = 10;

These new errorbar object properties control the lengths of the error bars in each direction:

• XNegativeDelta and XNegativeDeltaSource — Length of left side of horizontal error bars

• XPositiveDelta and XPositiveDeltaSource — Length of right side of horizontal error bars

• YNegativeDelta and YNegativeDeltaSource — Length of lower portions of vertical error bars

• YPositiveDelta and YPositiveDeltaSource — Length of upper portions of vertical error bars

Compatibility Considerations

These errorbar object properties still run, but have been replaced with new properties.

To control the data points at which markers display, use the MarkerIndices property of lines. For example, this code displays a marker every 10 data points.

x = linspace(0,10,500);
y = sin(x);
plot(x,y,'-o','MarkerIndices',1:10:length(y))

Plot histograms using histogram and histogram2 by directly passing in the bin counts. When you use this method, histogram and histogram2 do not do any data binning.

Commands that require computing the contour matrix now perform faster, such as:

• Returning the contour matrix as an output argument from the contour or contourf functions

• Querying the value of the ContourMatrix property of a contour object

The readtable function detects and returns date and time data as datetime type.

Compatibility Considerations

Previously, readtable function returned date and time data as character vectors. To preserve that behavior use T = readtable(filename,'DatetimeType','text').

You can control and customize how data is imported from text and spreadsheet files using the detectImportOptions function.

The detectImportOptions function returns a SpreadsheetImportOptions object for spreadsheet files and a DelimitedTextImportOptions object for text files. Use these objects with readtable to customize import options, such as:

• Import bad or missing data.

• Import only a subset of data using the SelectedVariableNames property.

• Customize the decimal separator and thousands separator for numeric data using the DecimalSeparator and the ThousandsSeparator properties.

• Import data as logical variables from a text file.

For more information on properties of objects created by the detectImportOptions function, see SpreadsheetImportOptions and DelimitedTextImportOptions.

The VideoReader object now supports full rate reading for HD Videos.

Now read minibatches from the ImageDatastore object using the ReadSize property. See imageDatastore function.

To speed up working with large data files use the TallDatastore object to recreate MATLAB tall arrays from files written to disk by the write function. You can use the TallDatastore object to efficiently load and work with data that has been previously preprocessed and cleaned up.

Use the jsondecode function to parse JSON text and convert it into MATLAB data types.

Use the jsonencode function to encode MATLAB data into JSON-formatted text.

You now can write blank cells in place of <missing> values using the writetable function.

The functions readtable, textscan, tabularTextDatastore, and spreadsheetDatastore support the importing of text as a string data type. For example, to read any text variable in the file myfile.txt as a string array, use T = readtable('myfile.txt','TextType','string'). For more information on string arrays, see Characters and Strings.

To create custom HTTP header fields, use the 'HeaderFields' argument in the weboptions function.

To specify HTTPS certificates, use the 'CertificateFilename' argument in the weboptions function.

The CDF library has been upgraded to version 3.6.1.

Tall arrays provide a way to work naturally with out-of-memory data. Many MATLAB operations and functions work the same way with tall arrays as they do with in-memory arrays. However, tall arrays are not stored directly in memory and are evaluated by request using gather. MATLAB automatically optimizes the queued calculations by minimizing the number of passes through the data. For more information, see Tall Arrays.

You can create tall numeric arrays, cell arrays, categoricals, strings, datetimes, durations, or calendar durations, and you can use any of these tall types as variables in a tall table. For more information, see Functions That Support Tall Arrays (A–Z).

You can clean missing data from an array or table using the following functions:

• ismissing — Find elements with missing values.

• standardizeMissing — Inserts missing value indicators.

• fillmissing — Replaces missing values with a specified method, such as linear interpolation or a constant value.

• rmmissing — Removes missing entries.

You now can exclude NaNs when calculating cumulative statistics with the cumsum, cummin, and cummax functions.

The discretize function accepts datetime and duration arrays as inputs.

You can pan or zoom in a single dimension using the new constrained options.

• To pan in a single dimension, first enable panning mode; for example, select the pan icon in the figure toolbar. Then, click and drag the tick marks or tick labels of the x-axis, y-axis, or z-axis to pan in that direction. The visual indicates that you are performing a constrained pan operation. Alternatively, right-click the axes and set the pan constraint using the context menu. See pan for information about the programmatic alternative.

• To zoom in a single dimension, first enable zooming mode; for example, select one of the zoom icons in the figure toolbar. For 2-D plots, click and drag the mouse in approximately the horizontal or vertical direction. The visual indicates that you are performing a constrained zoom operation. Alternatively, right-click the axes and set the zoom constraint using the context menu. For 3-D plots, use the context menu. See zoom for information about the programmatic alternative.

Now you can display most 2-D plots in your app. For more information, see Graphics Support in App Designer.

Add legends and color bars to your plots in App Designer. For more information, see Graphics Support in App Designer.

Use App Designer to display tabular data in your app. Drag a Table component onto the canvas and edit the Data property in the code view to display your data.

If your Table component displays a large number of rows and columns, you might notice a brief delay and a progress indicator as you scroll through the table in your running app. The delay occurs as MATLAB refreshes your data.

Write a callback function and share it among multiple components in your app. Right-click on a component in the canvas or the Component Browser and select Callbacks from the context menu. The Add Callback Function dialog box allows you to specify a new callback name or select from a list of existing callbacks.

• The resizing behavior of labeled components is improved.

• The names of labeled components are now based on the label text, making it easier to identify the components in the Component Browser and code view.

• Ungrouped labels are accessible in the App Designer Component Browser by default.

• Now you can edit the default value for a numeric edit field or spinner directly on the canvas.

• Duplicate any component into a different parent container by pressing Ctrl, selecting the component, and dragging the duplicated component into the target container.

Click the Show Tips button in the App Designer code view to see a brief overview of the coding workflow. The tips point to specific areas of App Designer and guide you through the basic steps of creating an app.

The Position property of App Designer components uses a 1-based origin in pixel units. In R2016a, App Designer components used a 0-based origin.

Compatibility Considerations

When you use R2016b to run an App Designer app created in R2016a, the UI components are shifted down and to the left by one pixel. You can use App Designer to correct the issue by opening and saving the app in R2016b before running it.

Similarly, when you use R2016a to run an App Designer app created in R2016b, the UI components are shifted up and to the right by one pixel.

ValueChangingFcn is a new property for the EditField component. When you specify a callback for the ValueChangingFcn property, the callback executes as the user edits the value at run time.

These containers include an OuterPosition property for accessing the location and size of their outer bounds. They also include an InnerPosition property for accessing the location and size of their drawable area.

• Panels — See Uipanel Properties for more information.

• Button groups — See Uibuttongroup Properties for more information.

• Tab Groups — See Uitabgroup Properties for more information.

The color picker that the uisetcolor function displays has been redesigned to include the following options:

• A palette of standard colors at the top

• A palette of recently selected colors in the center

• RGB input fields that update the color preview as you edit the values

You no longer need to include files accessed using standard file format functions or low-level I/O functions. The Package App dialog box automatically includes:

• Files that are accessed using standard file format functions. These dependent files include text, spreadsheets, images, audio, and video files. Scientific data formats are the only standard file formats that are not supported.

• Files that are accessed using low-level I/O functions.

For a list of supported functions, see Standard File Formats. For a list of supported I/O functions, see Low-Level File I/O.

Graphics that contain large numbers of markers have improved performance and use less memory.

Performance is improved for MATLAB code that is dominated by tight loops, straightforward indexing, and simple math.

Performance is improved for creating simple objects in MATLAB. Improvements apply to MATLAB and MathWorks Toolbox objects (for example, datetime, inputParser) and user-authored objects. For more information, see Object Constructors: Construct objects faster with certain constraints.

The MATLAB Support Package for Android™ Sensors and the MATLAB Support Package for Apple iOS Sensors now work on the MathWorks Cloud.

For information about how to connect your Android device to the Cloud, see the "Use MATLAB on the MathWorks Cloud" subsection in "Set Up and Connect to Android Device" in the MATLAB Support Package for Android Sensors documentation.

For information about how to connect your Apple iOS device to the Cloud, see the "Use MATLAB on the MathWorks Cloud" subsection in "Set Up and Connect to Apple iOS Device" in the MATLAB Support Package for Apple iOS Sensors documentation.

Write to shift registers using the MATLAB Support Package for Arduino^® Hardware.

You can use MATLAB commands to create pulse-width-modulated (PWM) signals and control servo motors from GPIO pins on the Raspberry Pi™ hardware. For more information, see MATLAB Support Package for Raspberry Pi Hardware.

You can use the MATLAB Support Package for Raspberry Pi Hardware with the Raspberry Pi 3 Model B hardware board.

You can use the MATLAB Support Package for Raspberry Pi Hardware with Raspberry Pi Sense HAT board to read from the sensors and joystick, and write to the LED matrix.

The components that you can communicate with from the support package are:

• Humidity sensor - Read the relative humidity and the ambient temperature.

• Pressure sensor - Read the barometric air pressure and the ambient temperature.

• IMU sensor

  • Accelerometer - Read the linear acceleration along the x, y, and z axes.

  • Gyroscope - Read the angular velocity along the x, y, and z axes

  • Magnetometer - Read the magnetic field along the x, y, and z axes.

• Joystick - Read the status of the joystick.

• LED matrix - Write to a pixel, display an image, or display a message on the 8x8 RGB LED matrix.

Run Linux^® and file management commands faster with performance improvements to the system, getFile, putFile, and deleteFile functions in the MATLAB Support Package for Raspberry Pi Hardware.

For more information, see HTTP Interface.

Call MATLAB functions and evaluate MATLAB statements from Java^® programs synchronously or asynchronously. Java programs can pass data to and get data from the MATLAB base workspace. For more information, see MATLAB Engine API for Java.

Classes derived from matlab.mixin.SetGet support inexact property name matching by default in calls to set and get. To require exact property name matching, derive your class from the matlab.mixin.SetGetExactNames class.

Classes derived from matlab.mixin.SetGetExactNames require case-sensitive, exact property name matches in calls to the set and get methods.

Create easily readable, navigable, and archivable reports of your test results using the TestReportPlugin. You can generate reports in .docx and .pdf formats. For more information, see the matlab.unittest.plugins.TestReportPlugin class.

Use the TAPPlugin to produce a Test Anything Protocol (TAP) stream of your test output. You can integrate this stream into continuous integration systems like Jenkins™ or TeamCity^®. The new producingVersion13 method formats the stream using version 13 of the TAP format. With this format, you can include test diagnostics in YAML blocks. For more information, see the producingVersion13 method of the TapPlugin class.

As of R2016b, MATLAB scripts can contain local functions. You can use local functions in your script-based unit tests to promote code reuse and readability by defining helper functions for your tests. For an example of local, helper functions in a script-based test, see Write Script-Based Test Using Local Functions.

If you use the verifyThat, assertThat, assumeThat, or fatalAssertThat qualifications with the IsSubstringOf constraint to test that an empty character vector is a substring of any nonempty character vector, the qualification now passes. In previous versions of MATLAB, this qualification failed. For example, the following test now passes in MATLAB R2016b.

Compatibility Considerations

Prior to MATLAB release R2016b, tests such as testCase.verifyThat('',IsSubstringOf('any character vector')) failed. Update any tests that rely on the previous behavior.

Significant overhead has been removed from object construction. These optimizations result in some changes in the behavior of object constructors, which are described in the next five items.

Compatibility Considerations

Class Destructor Called in Additional Conditions

In previous releases, when an error occurred in the constructor, MATLAB called the class destructor only if an object property was assigned a value in the constructor. With release R2016b, MATLAB also calls the class destructor when an error occurs under these conditions:

• A reference to the object is present in the code prior to the error.

• An early return statement is present in the code before the error.

These changes mean that MATLAB calls class destructors in more cases than in previous releases. The destructor must be able to operate on partially constructed objects. For more information, see Support Destruction of Partially Constructed Objects.

Returning Before Calling Superclass Not Allowed

In previous releases, constructors could return conditionally before calling the superclass constructor. With release R2016b, constructors cannot use early returns to conditionalize calls to the superclass constructor.

Revise any constructors that use returns to conditionalize calls to superclass constructors. For more information, see Subclass Constructors.

Path Change in Constructor Applies Immediately

In previous releases, path changes that remove the class of the executing constructor from the path did not affect the visibility of the class. With release R2016b, changes to the path made by the constructor are applied immediately. This new behavior is the same as that of path changes made in ordinary methods.

If a constructor removes the class folder from the path, MATLAB cannot access the class definition. The constructor can use the mlock function to keep the class definition in memory if changing the path in the constructor is necessary.

Changes to Error IDs

Error IDs have changed for certain constructor-related errors. These changes include the IDs for errors thrown for these conditions:

• Too many inputs

• Too many outputs

• Too few inputs

• Too few outputs

• Illegal superclass constructor call

Update any error handlers that rely on specific error IDs.

InstanceCreated Event Not Triggered When Constructor Does Not Return Object

If an object constructor does not return the constructed object, MATLAB does not trigger the InstanceCreated event. For more information, see Output Object Not Assigned.

You cannot listen for the InstanceCreated event if an object constructor does not return the constructed object to the caller.

MATLAB supports passing empty (0-length) Java arrays to Java methods that take an array of type other than Object.

Compatibility Considerations

Before MATLAB release R2016b, MATLAB converts zero-length Java arrays to null when the method takes an array of type other than Object.

MATLAB supports the following versions of CPython:

• Version 2.7

• Version 3.3

• Version 3.4

• Version 3.5

For more information, see Install Supported Python Implementation.

Support for Python^® version 3.3 will be discontinued in a future release.

Compatibility Considerations

To ensure continued support for your applications, consider upgrading to another supported version of Python — version 3.4 or 3.5.

Use the MATLAB Comparison tool to review changes to files such as live scripts and MAT-files from your external source control client. For more information, see Customize External Source Control to Use MATLAB for Diff and Merge.

To reuse code from another repository, you can specify Git™ submodules. For more information, see Add Git Submodules.

Remove stale working copy locks using the SVN Cleanup option. For more information, see Get SVN File Locks.

To ensure continued support for building your MEX-files, consider upgrading to another supported compiler. For an up-to-date list of supported compilers, see the Supported and Compatible Compilers website.

Live scripts combine code, output, and formatted content together in a single interactive environment called the Live Editor. Add formatted text, images, hyperlinks, and equations to create an interactive narrative that can be shared with others.

In the Live Editor you can:

• Write, execute, and test code in a single interactive environment

• Generate results and graphics alongside the code that produced them.

• Run blocks of code individually or run the whole file.

• See errors at the location in the file where they occur.

• Include mathematical equations, images, and hyperlinks as supporting material.

• Share live scripts with other MATLAB users or convert them to HTML or PDF for publication.

For more information about live scripts, including incompatibilities and information about the Live Script file format, see What Is a Live Script?.

Install, uninstall, query, and package toolboxes programmatically.

• To package toolboxes, use the matlab.addons.toolbox.packageToolbox function.

• To query or modify the version of a toolbox, use the matlab.addons.toolbox.toolboxVersion function.

• To install a toolbox, use the matlab.addons.toolbox.installToolbox function.

• To uninstall a toolbox, use the matlab.addons.toolbox.uninstallToolbox function.

• For information about installed toolboxes, use the matlab.addons.toolbox.installedToolboxes function.

Complete parameter names and options when entering commands in MATLAB. For example, if you type plot(1:10,' and press the Tab key, MATLAB displays a list of possible parameter names and options for the plot function.

Completion of parameters and options is not available for all functions.

To pause the execution of a program while it is running, in the Editor tab, click the Pause button. MATLAB pauses execution at the next executable line.

You can indicate which folders are excluded from the user's MATLAB path when they install your toolbox. By default, any of the toolbox folders that are on your path when you create the toolbox are added to the user's path. For more information, see Create and Share Toolboxes.

MATLAB can now migrate preferences from MATLAB versions up to three releases immediately preceding the release starting up. For example, if you start MATLAB R2016a for the first time and a preferences folder exists for R2014b, MATLAB migrates the preferences from R2014b to R2016a. If two or more preferences folders for the previous three releases exist, MATLAB imports the preferences from the latest preferences folder. For more information, see Preferences MATLAB Uses When Multiple Releases Are Installed.

Compatibility Considerations

On Mac platforms, migrating preferences might result in an out-of-date MEX options file. For more information, see SDK "macosx10.8" cannot be located Error Message.

Currently, the default encoding scheme on Mac platforms is determined by the OS X user locale setting. In a future release, the default encoding scheme will be UTF-8.

Compatibility Considerations

In a future release, the UTF-8 version of the MathWorks locale database will be the default on Mac OS X systems. Any text file created in MATLAB that is encoded in the user default encoding and contains characters other than 7-bit ASCII characters must be converted to the UTF-8 encoding scheme. Otherwise, MATLAB and other MathWorks products might not be able to load the files properly.

Do not convert text files to UTF-8 if you share them with users on Windows platforms.

How to Change the MATLAB Default Encoding to UTF-8

If you have text files containing non-7-bit ASCII characters, you must convert the encoding in the files before changing the default encoding on your computer. For instructions, see How to Convert Text File Encoding to UTF-8.

You can change the default encoding scheme on Mac OS X platforms by using the UTF-8 locale database found in the matlabroot/bin folder.

To change the default locale database, type:

mldir = fullfile(matlabroot,'bin');
copyfile(fullfile(mldir,'lcdata.xml'),...
  fullfile(mldir,'lcdata_default.xml'));
copyfile(fullfile(mldir,'lcdata_utf8.xml'),...
  fullfile(mldir,'lcdata.xml'));

Alternatively, you can change the default locale database by setting an environment variable on your computer:

1. Set the environment variable, MWLOCALE_LCDATA_FILENAME, with the UTF-8 version of the locale database name, lcdata_utf8.xml, in the environment file, environment.plist. Please see this article from the Mac OS X Developer Library, Technical Q&A QA1067 "Setting environment variables for user processes" at http://developer.apple.com/library/mac/#qa/qa1067/_index.html.

2. Close MATLAB if it is currently running.

3. Start MATLAB by double-clicking the MATLAB icon in the Applications folder.

How to Convert Text File Encoding to UTF-8

Before converting a file, copy the file to a new directory.

Use the Mac OS X TextEdit application to convert the file encoding. For example:

1. Open a MATLAB text file with TextEdit.

2. Select File -> Save as...

3. Change the file name.

4. Change Plain Text Encoding: to Unicode (UTF-8).

5. Save the file.

Alternatively, the following MATLAB function, convert_file_encoding, creates a new text file with different encoding.

function convert_file_encoding(infile,outfile,from_encoding,to_encoding)
 
if strcmp(infile(end-2:end),'mdl');
    isMDL = 1;
else
    isMDL = 0;
end
 
 
fpIn = fopen(infile,'r','n',from_encoding);
fpOut = fopen(outfile,'w','n',to_encoding);
 
while feof(fpIn) == 0
    lineIn = fgets(fpIn);
    if isMDL && strncmp('SavedCharacterEncoding',strtrim(lineIn),22)
        lineIn = regexprep(lineIn,from_encoding,to_encoding);
    end
 
    fwrite(fpOut,lineIn,'char');
end
 
fclose(fpIn);
fclose(fpOut);
end

To use this function, you need to know the current encoding, from_encoding.

• For MATLAB R2010b or later:

  ret = feature('locale');
  from_encoding = ret.encoding;
  

• For MATLAB R2008a through R2010a:

  ret = feature('locale');
  [t,r] = strtok(ret.ctype,'.');
  from_encoding = r(2:end);
  

For example, a file, myFile.m, was created with MATLAB encoding set to ISO-8859-1. To convert the file to UTF-8, type:

convert_file_encoding('myFile.m','myFileUTF8.m','ISO-8859-1','UTF-8')

View and modify the default locale and format of datetime objects in the Command Window Preferences. For more information, see Set Command Window Preferences.

You can specify logical output with the zeros, ones, and eye functions.

The cellstr, deblank, and strtrim functions no longer remove significant leading or trailing whitespace characters, such as nonbreaking space characters. The most common whitespace characters that are significant are char(133), char(160), char(8199), and char(8239).

Compatibility Considerations

Prior to MATLAB release R2016a, the cellstr, deblank, and strtrim functions removed all leading or trailing whitespace characters, including significant whitespace characters.

The rowfun and varfun functions no longer add row names to the output table when you use the 'GroupingVariables' parameter to specify the grouping variables.

Compatibility Considerations

Prior to MATLAB release R2016a, the rowfun and varfun functions added row names to the output table when using the 'GroupingVariables' parameter. To add row names, assign them to the RowNames property of the output table. For more information on table properties, see Table Properties.

You can now set breakpoints at any time, whether MATLAB is idle or busy running a file.

You now can compute statistics in a sliding window along a dimension of an array with the movmean, movsum, movmedian, movmax, movmin, movvar, and movstd functions.

The std function can calculate the standard deviation of a datetime or duration array.

You now can exclude NaNs from duration arrays when using the mean, median, std, and sum functions.

You also can exclude NaTs from datetime arrays when using the mean, median, and std functions.

The centrality function computes several different types of node centrality, such as 'degree', 'betweenness', and 'pagerank'. The nearest function calculates the nearest nodes within a specified distance of a source node.

The algorithm of the svds function shows improved performance and convergence behavior with a wide variety of matrices.

Compatibility Considerations

Three new options for sigma are being introduced to svds to calculate the largest and smallest singular values of a matrix: 'largest', 'smallest', and 'smallestnz'. Previously, using a value of 0 for sigma was common when calculating the smallest singular values.

svds(A,k,0) now returns a warning. Use svds(A,k,'smallest') to find the smallest singular values instead.

The median function computes the median of an array faster.

Calculating the cumulative minimum, maximum, product, and sum with the cummin, cummax, cumprod, and cumsum functions is now faster.

You now can use the data cursor to select nodes in a graph and display basic information, such as the node ID and degree. See Display Data Values Interactively for more information about data cursors, or Add Node Properties to Graph Plot Data Cursor for an example involving a graph plot.

Selecting a graph plot also enables the use of plot tools to interact with the graph, such as Plot Browser and Property Editor. See Customize Graph Using Plot Tools for more information.

To plot data in polar coordinates, use the polarplot function. You can modify the resulting polar axes, such as changing the limits or orientation, by setting Polar Axes Properties.

The polarplot function supersedes the polar function.

To create charts with two y-axes, use the yyaxis function. You can plot data against either y-axis using common charting functions, such as plot or errorbar. You can customize each y-axis by setting properties of the axes object.

The yyaxis function supersedes the plotyy function. For an example of its use, see Create Chart with Two y-Axes.

To add a title to a legend, use the new Title property of the legend or using the title function, for example:

plot(rand(3))
l = legend('Line 1','Line 2','Line 3');
title(l,'My Legend')

Also, now you can highlight charts in the axes when you click the associated legend item. Set the new ItemHitFcn property of the legend to a callback function that changes properties of the charts. For an example, see Create Interactive Legends Using Callbacks.

You now can link and brush data in histogram2 plots.

Plot mathematical expressions using a family of new and updated function plots. These functions supersede the existing ez family of functions, such as ezplot.

• fplot plots 2-D lines, including parametric lines. Supersedes ezplot.

• fplot3 plots 3-D parametric curves. Supersedes ezplot3.

• fcontour plots 2-D contours. Supersedes ezcontour.

• fsurf plots 3-D surfaces, including parametric surfaces. Supersedes ezsurf.

• fmesh plots 3-D meshes, including parametric meshes. Supersedes ezmesh.

Compatibility Considerations

The behavior of fplot changed in these ways:

• Issues a warning when using a string to define the function to plot. Instead, use an anonymous function or a function handle.

• Issues a warning when returning two output arguments. Instead, return the function line object and use its XData and YData properties.

• No longer supports specifying the y-axis limits as an input argument. Instead, use the ylim function.

• No longer supports specifying the number of evaluation points as an input argument. Instead, specify the MeshDensity property.

• No longer supports specifying the error tolerance as an input argument.

Graphics that contain markers have improved performance and quality. For more information, see opengl.

For axes in a 3-D view, panning and zooming now shift the view of the data by modifying the axis limits, instead of moving the entire axes. The axes box stays in the same location within the figure. Previously, panning and zooming modified camera properties, which moved the entire axes around within the figure.

Compatibility Considerations

If you have an axes in a 3-D view, then the behavior of pan and zoom is different. For the old behavior, use one of these options:

• Use the context menus when in pan or zoom mode. For example, when you are in zoom mode, right-click over the axes and select 3D Options > Camera Pan and Zoom.

• Use the setAxes3DPanAndZoomStyle function to specify the behavior, for example:

  ax = gca;
  z = zoom;
  setAxes3DPanAndZoomStyle(z,ax,'camera')

• Use the camera toolbar. To view the camera toolbar, select View > Camera Toolbar from the figure menu.

If you are using a Windows NVIDIA^® graphics driver older than version 9.18.13.4052 (or 340.52 in NVIDIA driver version convention), then MATLAB reverts to using software OpenGL^® instead of hardware-accelerated OpenGL. Hardware-accelerated OpenGL is not available by default due to known instabilities with the driver when running MATLAB. To take advantage of all the visual and performance benefits of hardware-accelerated OpenGL, update your graphics driver to the latest version. For more information, see System Requirements for Graphics.

Printed and saved figures now match the size of the figure on the screen by default. Previously, printed and saved figures were 8-by-6 inches by default. This change affects figures printed to a printer or saved to a bitmap image or vector graphics file format, for example, using the print and saveas functions.

Compatibility Considerations

The size of printed or saved figures might be different because now the default value for the PaperPositionMode property of figures is 'auto' instead of 'manual'. To get the previous behavior, set the default value back to 'manual' using one of these techniques:

• Use the new print preference option. Print preferences persist across MATLAB sessions. You can set the print preference to either 'auto' (new behavior) or 'manual' (previous behavior), for example:

  matlab.graphics.internal.setPrintPreferences('DefaultPaperPositionMode','manual')

  To query the current print preference value, use the following command. If you set a preference, then the command returns 'auto' or 'manual'. If you did not set a preference, then the command returns 'unset'.

  matlab.graphics.internal.getPrintPreferences

• Set the default value on the root object. This option affects only new figures in the current MATLAB session.

  set(groot,'defaultFigurePaperPositionMode','manual')

  For an existing figure, set the PaperPosition property to 'default', for example:

  set(gcf,'PaperPosition','default')

Print or save figures that fill the page using the new '-fillpage' and '-bestfit' options for the print function. These options maximize the size of the figure while leaving a minimum page margin of 0.25 inch. The '-bestfit' option preserves the figure's aspect ratio. The '-fillpage' option ignores the aspect ratio. Both options are valid only when printing a figure to a printer or saving it to a paged format (PDF and full page PostScript^®).

When you save a figure using File > Save As, the size of the saved figure now honors the figure's PaperPosition property value. By default, the PaperPosition property recalculates according to the size of the figure on the screen. As a result, the saved figure matches the size of the figure on the screen. However, if you change the PaperPosition property value, then the saved figure uses the specified size. Previously, the saved figure matched the size of the figure on the screen regardless of the PaperPosition property value. For the old behavior, set the figure's PaperPositionMode property to 'auto' before saving the figure:

set(gcf,'PaperPositionMode','auto')

Compatibility Considerations

The size of saved figures might be different.

App Designer is a rich application development environment for developing apps. Major App Designer features include:

• Numerous user interface components

  In addition to standard components, such as buttons, check boxes, and panels, App Designer also offers gauges, lamps, knobs, and switches.

• Integrated editor, property sheets, and property inspector

  The editor generates code as you lay out your app and customize component properties. The editor has coding alerts and many of the debugging features that are available in the MATLAB Editor. The integrated property sheets enable you to set commonly used properties for components, such as default component values, text, and text font styles. The property inspector provides access to all writable properties.

• Enhanced code structure

  App Designer generates code based on your component selection and layout. App Designer structures the code for readability and does not generate unnecessary code. In addition, Areas that App Designer manages are set to read-only access, so you cannot accidently overwrite or delete required code.

If you built apps using GUIDE in the past, be aware that there are some important differences between GUIDE and App Designer in terms of functionality and support for graphics workflows. For more information, see:

• Differences Between App Designer and GUIDE

• Graphics Support in App Designer

To get started using App Designer, see Create Simple App Using App Designer.

Performance improvement of the writetable function increases with table size.

The readtable function reads faster from Excel^® files.

In addition to Windows, the writetable function now writes to Excel files on Mac and Linux.

Compatibility Considerations

If you specify a range that exceeds the data being written, then writetable will not write to those cells. Previously, writetable filled the remaining cells with #N/A.

When writing NaT datetime values or <undefined> categorical values, writetable writes empty cells instead of NaT and <undefined>, respectively.

The spreadsheetDatastore function creates a SpreadSheetDatastore object for processing large collections of Excel files.

The datastore function now detects file formatting more accurately when creating a TabularTextDatastore object.

The datastore function now automatically includes only files with extensions .txt, .csv, .dat, .dlm, .asc, and .text by default.

Compatibility Considerations

If you want to include unsupported text file extensions, then specify them using the 'FileExtensions' parameter in the datastore function.

You now can organize an ImageDatastore according to specified labels using the Labels property. When creating an ImageDatastore object, you can use the LabelSource parameter to assign label names according to the file folder names. Labeling is useful for workflows in machine learning and neural networks, for example.

The splitEachLabel function creates new ImageDatastore objects according to a specified number or percentage of images from each label. splitEachLabel can also draw images randomly. This function is useful for testing and training sets, for example.

The countEachLabel function creates a summary table of all labels in the ImageDatastore and how many files belong to each.

The shuffle function randomly reorders the files in the original ImageDatastore and creates a new one.

The fileDatastore function creates a custom FileDatastore object that uses a specified custom read function to import the files.

The readtable function automatically detects delimiters, header lines, and variable names in text files.

Compatibility Considerations

You can restore the previous readtable defaults by specifying the delimiter, header line, or variable name parameter values explicitly, for example, readtable('file.txt','Delimiter',',','HeaderLines',0,'ReadVariableNames',true);

You now can use the tabularTextDatastore function to conveniently create a TabularTextDatastore object for large collections of text files.

You can use the imageDatastore function to conveniently create an ImageDatastore object for large collections of image data.

The writetable function automatically detects and adds quotations around text, categorical, and datetime variables containing an embedded delimiter (such as '\t').

You now can read from a TabularTextDatastore object with automatic detection of the Delimiter, NumHeaderLines, and ReadVariableNames properties. For more information, see TabularTextDatastore Properties.

Compatibility Considerations

You can restore the previous TabularTextDatastore defaults by specifying the delimiter, header line, or variable name parameter values explicitly, for example, tabularTextDatastore('file.txt','Delimiter',',','NumHeaderLines',0,'ReadVariableNames',true);

The imread function generates C-code for 8-bit grayscale and 24-bit truecolor JPEG images using a platform-specific shared library.

Measure the performance of your MATLAB code using the performance testing framework. The framework includes performance measurement-oriented features such as running your code several times to "warm-up" the code and accounting for noise in the measurements.

The performance test interface leverages the script, function, and class-based unit testing interfaces. Therefore, you can perform qualifications within your performance tests to ensure correct functional behavior while measuring code performance. Also, you can run your performance tests as standard regression tests to ensure that code changes do not break performance tests.

For more information, see Performance Testing Framework.

Graphics that contain markers have improved performance and quality. For more information, see opengl.

Performance improvement of the writetable function increases with table size.

The readtable function reads faster from Excel files.

The median function computes the median of an array faster.

Calculating the cumulative minimum, maximum, product, and sum with the cummin, cummax, cumprod, and cumsum functions is now faster.

Use the MATLAB Support Package for Raspberry Pi Hardware to bring live images into MATLAB from USB webcams attached to your Raspberry Pi hardware board.

With simple MATLAB functions preview and acquire single snapshots from the camera, and optionally set up a loop of acquired images. The webcam function creates the USB Camera object used to acquire images, and the snapshot function returns a single image from the camera.

MATLAB Support Package for Arduino Hardware provides a framework of classes that you can use to create custom applications to use with your Arduino device. The custom applications can be code, libraries, or devices that work with an Arduino. For more information, see Custom Arduino Add-On Device, Library, and CodePerformance Testing Framework in the MATLAB Support Package for Arduino Hardware documentation.

To install the support package, on the MATLAB Home tab, in the Environment section, click Add-Ons > Get Hardware Support Packages.

Measure the performance of your MATLAB code using the performance testing framework. The framework includes performance measurement-oriented features such as running your code several times to "warm-up" the code and accounting for noise in the measurements.

The performance test interface leverages the script, function, and class-based unit testing interfaces. Therefore, you can perform qualifications within your performance tests to ensure correct functional behavior while measuring code performance. Also, you can run your performance tests as standard regression tests to ensure that code changes do not break performance tests.

For more information, see Performance Testing Framework.

Use the testsuite function to create a suite of tests from your current working folder or from specified test content. If you have an explicit test suite, you can use test selectors and test runners.

In previous releases of MATLAB, you create explicit test suites with the methods in the matlab.unittest.TestSuite class. The testsuite function provides a more convenient means to create test suites.

You can programmatically access the diagnostic information on test results using a DiagnosticsRecordingPlugin. The DiagnosticsRecordingPlugin class records test qualification failures and events logged at Terse verbosity. However, you can configure the plugin to record passing diagnostics and logged messages at different verbosity levels.

If you run tests with the runtests function or the run method of TestSuite or TestCase, then the test framework uses a DiagnosticsRecordingPlugin plugin by default. Also, if you run performance tests with the runperf function or the run method of TimeExperiment, then the test framework uses this plugin by default.

For more information, see matlab.unittest.plugins.DiagnosticsRecordingPlugin.

The matlab.unittest.fixtures.WorkingFolderFixture class provides a fixture that creates a temporary folder and sets it as the current working folder. The test or the product under test can create files and modify the contents of the folder without affecting the source code or test folder structure.

Although both the WorkingFolderFixture and TemporaryFolderFixture classes create a temporary folder, the WorkingFolderFixture also sets the folder as the current working folder. At fixture teardown, the testing framework restores the current working folder to its previous state.

For more information, see matlab.unittest.fixtures.WorkingFolderFixture.

You can test set membership and uniqueness of the actual value set using set constraints in the matlab.unittest.constraints package. For example:

• HasUniqueElements tests if an actual value set has unique elements.

• IsSubsetOf tests if an actual value set is a subset of the expected value set.

• IsSupersetOf tests if an actual value set is a superset of the expected value set.

The matlab.unittest.fixtures.Fixture class enables you to create custom fixtures to configure the environment state required for tests. The applyFixture method of the Fixture class enables your custom fixture to delegate work to another fixture. When the testing framework tears down the custom fixture, it also tears down the fixture you used to set it up.

For more information, see matlab.unittest.fixtures.Fixture.applyFixture.

When you compare structures using the IsEqualTo or StructComparator classes, specify which fields to ignore using the 'IgnoringFields' name-value pair argument.

When you compare objects using the PublicPropertyComparator with the supportingAllValues static method, specify which properties to ignore using the 'IgnoringProperties' name-value pair argument. If the values are structures, then specify which fields to ignore using the 'IgnoringFields' option.

Now,you can create a PathFixture fixture that includes subfolders of the specified folder on the path. For more information, see the 'IncludingSubfolders' name-value pair argument of PathFixture.

Additionally, you can have the PathFixture fixture add the folder to the end (bottom) of the path. By default, the fixture adds a folder to the beginning (top) of the MATLAB path. For more information, see the 'Position' name-value pair argument of PathFixture.

Restrict property values to a specified class or a class compatible with the specified class. For more information, see Restrict Class of Properties.

Define only one property per line in the property block of a class definition. Also, you cannot define properties on the same line as the properties or end keywords.

Compatibility Considerations

In releases R2016a, MATLAB interprets any name following a property name as a restricting class. The second name is not interpreted as a property name. More than two names on a line cause an error. A single line in a property block can contain the property name, an optional restricting class, and an optional default value. Default values must be of a class that is compatible with the class restriction.

properties
   PropName ClassName = defaultValue;
end

You must change any existing property blocks that list more than one property per line to list only one property per line. The following list describes cases that you must change:

• The properties keyword is on the same line as property names.

• The end keyword is on the same line as property names.

• The entire properties block is on one line using white-space separators.

• More than two property names are on one line.

MATLAB interprets two property names on one line as a restricted property. If the second name is not a valid class name, MATLAB generates an error.

The event.hasListener function returns a logical true or false indicating if listeners exist for a specific event name and event source.

The PropertyAdded and PropertyRemoved events provide an event.DynamicPropertyEvent object as the event data that is passed to listeners of those events. This event data object has a property, PropertyName, that contains the name of the dynamic property whose addition or removal triggered the respective event.

Enumerations have improved compatibility with character arrays and cell arrays of strings. This compatibility enables conversion of characters to enumerations and the use of enumeration members in set membership and string comparison functions. For more information, see Conversion of Characters to Enumerations and Operations on Enumerations.

With release R2016a, the waitfor function works with any instance of a MATLAB handle class.

If you are using Git for source control, you can view information about your current branch relative to the remote tracking branch in the repository. Right-click the file or white space of the Current Folder browser and select Source Control > View Details. The Git information field indicates whether your committed local changes are ahead of, behind, or coincident with the remote tracking branch.

If you have folders in your source control repository, the Current Folder browser shows an icon for the folder that summarizes the status of the contents of the folder. The tooltip for the icon displays a summary of the changes in the folder.

If the source control system supports storing folders, the Current Folder browser displays the appropriate status icon for the folder and its contents. Otherwise, it displays either a dot indicating that the folder is not under source control or the Modified icon to indicate that files within the folder are modified. SVN supports storing folders, but Git does not.

You can start the MATLAB Engine for Python asynchronously using the async keyword argument in the matlab.engine.start_matlab and matlab.engine.connect_matlab commands.

MATLAB builds with an updated version of the Boost library, version 1.56.0.

Compatibility Considerations

If you use any Boost library in a MEX function, you might not be able to load that function if you do not use Boost library version 1.56.0.

The mex command -f option does not accept arguments with .bat or .sh file extensions.

Instead of using the -f option to specify a compiler, use the work flows described in Change Default Compiler.

You can modify compiler build options using mex command options. For example, use the -L and -I options to locate libraries on your system. Use the varname=varvalue option to pass options to the compiler.

For the complete list of mex command options, see the option1 ... optionN input argument.

To ensure continued support for building your MEX-files, consider upgrading to another supported compiler. For an up-to-date list of supported compilers, see the Supported and Compatible Compilers website.

Add-ons extend the capabilities of MATLAB by providing additional functionality for specific tasks and applications, such as connecting to hardware devices, additional algorithms, and interactive apps. Add-ons encompass a wide variety of resources, including products, apps, support packages and toolboxes, and are available from MathWorks and from the global MATLAB user community.

Using the new Add-On Explorer, you can browse and install available add-ons directly from MATLAB.

• To access the Add-On Explorer in MATLAB, go to the Home tab and click the Add-Ons icon.

• To manage installed add-ons, go to the Home tab, and select Add-Ons > Manage Add-Ons.

For more information, see the Add-Ons documentation.

Compatibility Considerations

To continue using your apps and custom toolboxes from previous MATLAB installations, you must migrate them to the current release:

1. On the Home tab, select Add-Ons > Manage Add-Ons.

2. Click the Import button.

Improved Navigation

The 2015b release includes a redesigned left-side navigation pane to facilitate topic exploration. From this pane you can:

• View the current product, as well as adjacent categories relevant to your current area of focus.

• Access basic product links such as getting started information, examples, functions and other references, release notes, and PDF documentation. Click the icon to the right of the product name to bring up available options.

  

• Explore and navigate faster through subsections of a page. Click a subsection title to access its content. For example, suppose you want to view all the input arguments for the imshow function. Open the function reference page and in the left-side navigation pane, click Input Arguments.

  

Additional Introductory Material

Product pages and their primary categories now contain enhanced introductory material. New features include product and category overviews, images, quick links, and featured examples.

New Search Bar Location

A redesigned search bar is more visible on every page throughout the documentation.  You now can easily find and use the search tool whenever you need it.

New browser-style keyboard shortcuts

New keyboard shortcuts allow better navigation of the MathWorks documentation.

Persistent Font Size

Font size now persists over multiple MATLAB Help browser and MATLAB Web browser sessions. To adjust the font size, use the Ctrl + Mouse Scroll keyboard shortcut.

MATLAB now ensures command completions have the correct capitalization. For example, if you type help Contain and press Tab, MATLAB displays help containers in the command line.

When calling the help command, you receive suggested corrections for mistyped function names. Press Enter to accept the suggestion or Esc to cancel.

The appearance of the MATLAB desktop is improved for these system configurations:

• Macintosh systems with Apple Retina displays.

• Windows systems in which the DPI (dots-per-inch) value is higher than 96.

The MATLAB Desktop is now properly scaled and sharper on these systems than in previous releases. Be aware that the icons in the Toolstrip might still look slightly blurry on some systems.

For more information about the DPI-aware changes to MATLAB, see DPI-Aware Behavior in MATLAB.

Compatibility Considerations

• The Toolstrip, Command Window fonts, and Editor fonts might be larger than in previous releases. These differences might occur on Windows systems in which the display DPI value is higher than 96. If you have nondefault font sizes selected in MATLAB preferences, you might need to adjust those font sizes to make them look smaller.

• When publishing a document on a high-DPI system, the images saved to disk are larger than in previous releases or on other systems.

The findgroups function finds groups within grouping variables. Use these groups and splitapply to split data out of data variables and apply functions to each group of data.

The NaT function creates an array of Not-a-Time (NaT) values to represent unknown or missing datetime values.

The timezones function displays a list of IANA time zone names that you can use as inputs to the datetime function.

The timeofday function accounts for the Daylight Saving Time (DST) shift on days when the shift occurs in time zones that observe DST.

Compatibility Considerations

Before MATLAB release R2015b, the timeofday function ignored the Daylight Saving Time (DST) shift on days when the shift occurs.

You can get help using a variable by specifying it as an input to the help command. For example if you have a variable t = datetime, calling the command help t displays help text for the datetime class.

You can modify a Python module that is already loaded into MATLAB, using the MATLAB clear function and the Python importlib.import_module and reload functions. For an example, see Reload Modified User-Defined Python Module.

To pass a Python function to a Python function, use the function handle @ symbol. For an example, see Pass Python Function to Python map Function.

MATLAB displays the class name of a Python error, which provides more information about the error. See Troubleshooting Error Messages.

You can connect the MATLAB Engine for Python to a MATLAB session that is already running. For an example, see Connect Python to Running MATLAB Session.

You can use the MinGW-w64 version 4.9.2 compiler from TDM-GCC to build MEX files and standalone MATLAB engine and MAT-file applications. For more information, see Install MinGW-w64 Compiler.

For an up-to-date list of supported compilers, see the Supported and Compatible Compilers website.

MATLAB R2015b supports the Intel Fortran Composer XE 2013 compiler with Microsoft Visual Studio 2013 Professional (64-bit) for building MEX files and MATLAB engine applications.

MATLAB no longer supports the GNU gfortran compiler for building MEX files and MATLAB engine applications on Apple Mac platforms.

Support for these compilers will be discontinued in a future release, at which time new versions will be supported.

• Microsoft Visual Studio 2008 SP1 and Microsoft Platform SDK version 6.1

• Apple Xcode 5.1

For an up-to-date list of supported compilers, see the Supported and Compatible Compilers Web page.

MATLAB now displays the warning stack when a MEX file displays a warning. You can control the information displayed or suppressed by calling the warning function with the backtrace mode option before calling the MEX file.

As of R2015b, the TAPPlugin includes diagnostic information in the Test Anything Protocol (TAP) stream. For more information, see matlab.unittest.plugins.TAPPlugin.

You can add the XMLPlugin to the test runner to produce a JUnit-style XML file. Use the output file to integrate test results with continuous integration systems like Jenkins or TeamCity. For more information, see matlab.unittest.plugins.XMLPlugin.

Write plugins that immediately report when the test runner finalizes a test result. A test result is final when no remaining test content can modify the results. Examples of when the test runner might modify previously run test results include when it executes code inside of TestClassTeardown methods, or when it tears down shared test fixtures. For more information, see the reportFinalizedResult method of TestRunnerPlugin and Plugin to Generate Custom Test Output Format.

Write plugins that perform system-wide qualifications of a test suite with the QualifyingPlugin interface. For more information, see matlab.unittest.plugins.QualifyingPlugin.

Run a suite of tests in parallel using the runtests function and the Parallel Computing Toolbox™. For more information, see the 'UseParallel' name-value pair argument of runtests.

Add the FailOnWarningsPlugin plugin to the test runner to produce a qualification failure when a test issues a warning. For more information, see matlab.unittest.plugins.FailOnWarningsPlugin.

You can create a test case to use and debug your test class interactively using the TestCase.forInteractiveUse method. This method accepts a meta.class instance that describes a TestCase subclass. For more information, see matlab.unittest.TestCase.forInteractiveUse.

Compatibility Considerations

You should no longer call the constructor of a TestCase subclass to use the instance interactively. Instead, pass the meta.class instance into the forInteractiveUse method. For example, instead of creating a test case using the constructor of MyTestCase:

tc = MyTestCase;

create a test case using the forInteractiveUse method:

tc = matlab.unittest.TestCase.forInteractiveUse(?MyTestCase);

Create a CodeCoveragePlugin that reports on source code contained within subfolders of the specified folders and subpackages of the specified packages. For more information, see matlab.unittest.plugins.CodeCoveragePlugin.

You can use the runtests function to specify the name of a test suite element. For example, runtests('ATestFile/aTest'). The runtests function combines test suite element names with test files, test classes, packages, or folders to build and run your test suite. For more information, see runtests.

As of R2015b, you can use the 'RespectingSet' name-value pair argument in the Throws constraint to validate that the invocation of a function handle throws an exception with only a specified list of expected causes. The 'RespectingSet' name-value pair argument has a default value of false. To create a Throws constraint that is not satisfied if the expected exceptions contain causes that are not specified in the 'CausedBy' name-value pair, set 'RespectingSet' to true. For more information, see matlab.unittest.constraints.Throws.

Methods must be on the MATLAB path when called. For example, if you create an object and then change your current folder to a folder from which the method file is not visible, MATLAB returns an error when you call that method.

Compatibility Considerations

Before MATLAB release R2015b, after you create an object, you could call a method of that object even if the method definition was no longer on the MATLAB path. With release R2015b, methods must be on the MATLAB path when called.

If your class overloads numArgumentsFromSubscript, MATLAB calls this method instead of numel to determine the number of array elements involved in an indexing operation when the number of elements is greater than one.

If your class overloads numel, MATLAB still calls your overloaded numel method.

Before MATLAB release R2015b, MATLAB incorrectly computed the number of arguments expected for outputs from subsref and inputs to subsasgn for some indexing expressions that return or assign to a comma-separated list.

Compatibility Considerations

With release R2015b, MATLAB correctly computes the values of nargout and nargin according to the number of arguments required by the indexing expression. For more information, see Modify nargout and nargin for Indexing Methods.

The subsasgn function no longer supports a no output argument syntax that modifies the input argument.

Compatibility Considerations

Before MATLAB release R2015b, subsasgn modified the input argument when you did not specify an output argument. With release R2015b, you must assign an output argument or MATLAB returns an error:

Error using subsasgn
SUBSASGN must be called with an output.

The display function supports a second input argument Use this argument to specify the character array to display instead of the variable name.

MATLAB supports passing 0-length Java arrays to Java functions. To create such an array, use the javaArray function.

Compatibility Considerations

Before MATLAB release R2015b, MATLAB converted 0-length Java arrays to null.

The javaaddpath and javarmpath functions clear the definitions of all Java classes defined by files on the dynamic class path. As of MATLAB release R2015a, the functions do not use the clear java command, which also deletes global variables and variables from the MATLAB base workspace, and removes all compiled scripts, functions, and MEX functions from memory.

Use this cell function syntax to convert System.DateTime and System.String data to cell arrays of MATLAB data,

where obj is a .NET System.Object[,] array, and type is one of the following strings:

• {'System.DateTime'} — Convert System.DateTime elements to MATLAB datetime elements.

• {'System.String'} — Convert System.String elements to MATLAB strings.

• {'all'} — Convert all supported .NET types to equivalent MATLAB types.

A is a cell array, that is the same size as the obj array.

For an example, see Read Cell Arrays of Excel Spreadsheet Data.

In a file under source control in MATLAB, you can select any pair of file revisions to compare. Also, you can sort revisions by column headers in the Compare to Revision dialog box (for example, by date, revision number, or author). The Compare to Revision dialog box has an improved layout that places revision columns above the details pane, making it much easier to read.

Previously you could compare a revision only with your local file, which made investigation of older changes more difficult. You could not compare between other revisions, and you could not sort revisions.

For details, see Review Changes in Source Control.

There are two additional wall-clock options for measuring time while profiling your code. The 'performance' timer uses the wall-clock time from the clock that the operating system uses to measure performance. As of R2015b, this option is the default timer for profiling. The 'processor' timer uses the wall-clock time directly from the processor. For more information, type help profile at the command prompt.

Compatibility Considerations

As of R2015b, the default timer is 'performance'. In previous versions of MATLAB, the default profiler timer was 'cpu', which measures compute time instead of wall-clock time. You may notice differences in the reported times from previous versions of MATLAB. Also, depending on the code you are profiling, the summary of results can appear different.

On Windows platforms, the MATLAB system, dos, and ! commands add the /D flag to the startup of the Windows Command Processor (cmd.exe) program. The /D flag disables the running of these AutoRun strings in Windows registry:

• HKEY_LOCAL_MACHINE\Software\Microsoft\Command Processor

• HKEY_CURRENT_USER\Software\Microsoft\Command Processor

Compatibility Considerations

To preserve the behavior of previous releases, prepend cmd /C to your operating system command. For example, in MATLAB, the command,

!cmd /C "cd"

calls the cd command using the AutoRun values.

The graph and digraph functions enable creation of undirected and directed graphs.

After creating a graph object, there are numerous functions available for modifying the graph, analyzing its properties, applying search algorithms, and visualizing the structure. For more information, see Graph and Network Algorithms.

The histcounts2 function sorts bivariate data into 2-D bins with data dependent bin picking and options for bin control and normalization.

The deg2rad function converts angles from degrees to radians. The rad2deg function converts angles from radians to degrees.

The interp1 function accepts datetime arrays as an input argument.

The interp1, eps, cummax, cummin, cumsum, mod, and rem functions accept duration arrays as an input argument.

The algorithms for expm, logm, and sqrtm show increased accuracy, with logm and sqrtm additionally showing improved performance.

The histcounts function accepts categorical arrays as an input argument.

Repeated calls to the xlsread, xlswrite, readtable, and writetable functions show significant performance improvement.

Use the datastore function to create an ImageDatastore, which can import data from image collections that are too large to fit in memory.

ImageDatastore is a compatible datastore for use with mapreduce.

In addition to UTF-8 and US-ASCII, TabularTextDatastore now supports all of the character encoding schemes that the fopen function supports, such as, ISO-8859-1, windows-1251, and Shift_JIS. For additional supported encoding schemes, see TabularTextDatastore Properties.

Now when modifying the Files property of an existing datastore, each string in the input cell array of strings must contain a full path to the file. Previously, the input cell array could contain folder names or strings with wildcard (*) characters to represent multiple files.

The Files property for all file-based datastores is now a column vector. Previously, the Files property was a row vector.

Compatibility Considerations

Although modifying the Files property of an existing datastore requires full paths to the files, this change does not affect the creation of a datastore using the datastore function. When creating a new datastore using the datastore function, you can specify the location of the files or folders as a single string or a cell array of strings in the form of a column or row vector. The strings also can contain wildcard characters to represent multiple files.

VideoReader now reads MPEG-4 and MOV video files more quickly on Mac OS.

You can specify the locale that the readtable and writetable functions use for month and day names. Specify the DateLocale name-value pair argument to read month and day names from text files, or to write month and day names to text files or spreadsheets.

The upgrade to the NetCDF library version 4.3.3.1 brings these enhancements:

• Many bug fixes in the library

• Fixes for older OPeNDAP servers that do not conform to DAP 2.0 protocol

The fopen function now supports additional character encoding schemes, including EUC-KR, GB2312, GB18030, and KOI8-R. After you call fopen, subsequent read and write operations such as fscanf, fprintf, fread, and fwrite use the specified character encoding.

The webread, websave, and webwrite functions can accept input arguments specified as datetime objects for requests to web services that accept dates and times as query parameters. To match the date and time format required by the web service you call, specify the Format property of a datetime object.

To specify the array format for query parameters that represent multiple values, specify the ArrayFormat property of a weboptions object. Pass the query parameters and the weboptions object as input arguments to the webread, websave, or webwrite functions.

The appearance of graphics is improved for these system configurations:

• Macintosh systems with Apple Retina displays

• Windows systems in which the DPI (dots-per-inch) value is higher than 96

Previously, MATLAB allowed the operating system to scale graphical elements on these high-DPI systems. That scaling helped to maintain consistent appearance and functionality, but it also introduced undesirable effects. Graphical elements often looked blurry, and the size of those elements was sometimes inconsistent.

Instead of relying on the operating system, MATLAB is now DPI-aware, which means that it takes advantage of the full system resolution to draw graphical elements (fonts, UIs, and graphics). Thus, graphical elements appear sharp and appropriately scaled regardless of your display DPI. For more information, see DPI-Aware Behavior in MATLAB.

Compatibility Considerations

• In order to display graphics at an appropriate scale, distances in pixels are now device-independent on Windows and Macintosh systems. If you set the Units property or FontUnits property of an object to 'pixels', the size of each pixel is as follows:

  • Windows systems — 1 pixel is 1/96 inch.

  • Macintosh systems — 1 pixel is 1/72 inch.

  • Linux systems — No change. Pixel size determined by display DPI.

  In most cases, you do not need to modify your code. Keep in mind that specifying the size and location of graphics components in pixels might not correspond to the actual pixels on your screen. For example, when the Units property of a figure is set to 'pixels', MATLAB reports the Position and CurrentPoint property values based on device-independent pixels, not the size of the actual pixels on the screen.

• MATLAB might report the size and location of objects as fractional values (in pixel units) more frequently than in previous releases. For example, your code might report fractional values in the Position property of a figure, whereas previous releases reported whole numbers for that same figure.

• The ScreenSize property of the root object might not match the display size reported by high-DPI Windows systems. Specifically, the values do not match when the Units property of the root object is set to 'pixels'. MATLAB reports the value of the ScreenSize property based on device-independent pixels, not the size of the actual pixels on the screen.

• When using getframe (or print with the -r0 option) on a high-DPI system, the size of image data array that MATLAB returns is larger than in previous releases. Additionally, the number of elements in the array might not match the figure size in pixel units. MATLAB reports the figure size based on device-independent pixels. However, MATLAB bases the size of the image array on the display DPI value.

• The ScreenPixelsPerInch property of the root object is now read only, and the value depends on the system:

  • Windows systems — The value is 96 DPI.

  • Macintosh systems — The value is 72 DPI.

  • Linux systems — The value is determined by your display DPI.

  Also, you cannot set or query the default value of the ScreenPixelsPerInch property. These commands now return an error:

  get(groot,'DefaultRootScreenPixelsPerInch')
  set(groot,'DefaultRootScreenPixelsPerInch')
  

  The factory value cannot be queried either. This command returns an error as well:

  get(groot,'FactoryRootScreenPixelsPerInch')

Axes objects now have an 'origin' option for the XAxisLocation and YAxisLocation properties. Use this option to display the x-axis or y-axis so that it passes through the origin point (0,0). These properties only affect 2-D views of the axes.

Numeric rulers are new objects that you can use to modify the appearance or behavior of the x-axis, y-axis, or z-axis. When you create an axes object, MATLAB creates a numeric ruler for each individual axis. Modify a particular axis by setting properties of the associated numeric ruler. Access the number ruler through the new XAxis, YAxis, or ZAxis property of the axes object.

Numeric rulers have several properties that offer new types of axis customizations. Control the format of the tick labels using the TickLabelFormat property. For example, you can display the tick labels as currency values or control the number of decimal places displayed. Additionally, you can control if the tick labels use exponential notation with the Exponent property.

For a list of properties, see Numeric Ruler Properties.

The histogram2 function plots bivariate histograms with data-dependent bin picking and options for bin control, normalization, and visualization.

When you specify an output argument with the histogram2 function, it returns an object that you can use to modify properties of the histogram. For example, you can change the number of bins in each dimension, use a different binning algorithm, or normalize the histogram in several ways. For more information, see Using histogram2 Objects.

The histogram function accepts categorical arrays as an input argument.

histogram objects created using categorical data contain some different properties than normal numeric histograms. For more information, see Histogram Properties.

Histogram plots created using either histogram or histogram2 have a context menu in plot edit mode that enables interactive manipulations in the figure window.

Area, bar series, and scatter series objects now support transparency. This table lists the new transparency properties for each object. Set these properties to a value between 0 (transparent) and 1 (opaque).

Alternatively, you now can use the alpha function to change the transparency of these objects. Specify the input to alpha as a value between 0 and 1, 'opaque', or 'clear' to affect these objects.

Control the appearance of contour labels by setting text properties with any clabel syntax. In R2014b and R2015a, not all clabel syntaxes supported name-value pairs to set text properties.

The changes to clabel are as follows:

• All syntaxes now support name-value pairs to set a useful subset of text properties.

• Syntaxes that previously supported name-value pairs to set text properties now support only a subset of text properties.

For the list of supported properties, see clabel.

Compatibility Considerations

There are some text properties that you can no longer set using clabel. For example, you cannot set the Parent, Children, or UserData properties as name-value pairs. All the syntaxes that are more restrictive in terms of supported text properties continue to return text objects. If necessary, you can use those text objects to set additional properties.

The opengl function now supports the hardwarebasic option. This option uses your graphics hardware, but disables these graphics features that are unstable with some graphics drivers:

• Align vertex centers feature for sharp vertical and horizontal lines

• Depth peel transparency feature for accurate transparency in overlapping 3-D objects

The disabled features might change in future releases as graphics features change and graphics hardware evolves.

Chart lines and primitive lines have a LineJoin property for controlling the style of the line corners. Options include round, chamfer, and miter styles.

The appearance of UIs have improved for the following high-DPI systems:

• Macintosh systems with Apple Retina displays

• Windows systems in which the DPI (dots-per-inch) value is higher than 96

These are the visual improvements you might see:

• UI components look sharp and render with full graphical detail.

• When you create a UI object, and specify the Units as 'pixels', the size of that object is now consistent with the size of other objects. For example, the size of a push button (specified in pixels) is now consistent with the size of the text on that push button (specified in points).

For more information about the new DPI-aware behavior, see DPI-Aware Behavior in MATLAB.

Compatibility Considerations

• In order to display UI components at an appropriate scale, distances in pixels are now device-independent on Windows and Macintosh systems. If you set the Units property or FontUnits property of an object to 'pixels', the size of each pixel is as follows:

  • Windows systems — 1 pixel = 1/96 inch

  • Macintosh systems — 1 pixel = 1/72 inch

  • Linux systems — No change. The size of a pixel is determined by the display DPI.

  In most cases, you do not need to modify your code. Keep in mind that specifying the size and location of UI components in pixels might not correspond to the actual pixels on your screen. For example, when the Units property of a figure is set to 'pixels', MATLAB reports the Position and CurrentPoint property values based on device-independent pixels, not the size of the actual pixels on the screen.

• MATLAB might report the size and location of objects as fractional values (in pixel units) more frequently than in previous releases. For example, your code might report fractional values in the Position property of a figure, whereas previous releases reported whole numbers for that same figure.

• The ScreenSize property of the root object might not match the display size reported by high-DPI Windows systems. Specifically, the values do not match when the Units property of the root object is set to 'pixels'. MATLAB reports the value of the ScreenSize property based on device-independent pixels, not the size of the actual pixels on the screen.

• UIs might appear larger than in previous releases on Windows systems in which the display scaling value is greater than 100% but less (or equal to) than 125%. Also, icons in those UIs might look slightly blurry because they are enlarged to accommodate the larger UI. To avoid these effects, set the Windows DPI scaling to 100%.

For a list of related changes in Graphics, see Graphics Display: Leverage DPI-aware MATLAB graphics for Apple Retina displays and high-resolution displays on Windows.

The new MATLAB execution engine includes performance improvements to function calls, object-oriented operations, and many other MATLAB operations.

These performance improvements result in significantly faster execution of many MATLAB programs with an average speed-up of 40% among 76 performance-sensitive applications from users. Of these tested applications, 13 ran at least twice as fast and only 1 slowed down by more than 10%.

The new execution engine uses just-in-time compilation of all MATLAB code which makes performance more uniform and predictable. The new engine offers improved quality and provides a platform for future performance optimizations and language enhancements.

Using dot-parentheses indexing to access elements of a table variable, for example x = T.V(I), has better performance.

• A categorical array can contain a larger number of categories.

• Categorical arrays with small numbers of categories use memory more efficiently.

• Some categorical comparison and assignment operations involving scalars are faster.

You can use the MATLAB Support Package for Raspberry Pi Hardware with Raspberry Pi 2 Model B hardware.

You can use MATLAB commands to connect to a BeagleBone Black board over a network. For more information, see MATLAB Support Package for BeagleBone Black Hardware.

The MATLAB Support Package for Apple iOS Sensors enables you to collect sensor data from your Apple iOS mobile device and log it in MATLAB. You can then process the sensor data in MATLAB in a variety of ways, including creating plots. You can collect data from these sensors:

• Acceleration

• Angular Velocity

• Orientation

• Magnetic Field

• Position

The Apple iOS sensors product requires:

• Installation of MATLAB Mobile™ on your Apple iOS device. You can acquire this application through the App Store.

• Your Apple device must use iOS version 7 or later.

• MATLAB version R2015a or later, for creating the connection to the application and logging sensor data.

• Installation of the MATLAB Support Package for Apple iOS Sensors.

The support package includes the command-line interface in MATLAB and the ability to interact with Apple iOS sensors, which is a separate tab in MATLAB Mobile. To connect to sensors on the phone and collect data, you create a mobiledev object in MATLAB. You make the connection between your computer running MATLAB and the phone via Wi-Fi^® or your cellular network. To get started, see Get Started with Apple iOS Sensors.

When you create custom help and add it to the MathWorks documentation, the help link appears on the Home Help page. For instance, if you add the sample Upslope Area Toolbox documentation, it appears as shown here.

When you click the link for your custom help, that help displays in the current window.

Previously, to access custom help that you added to MathWorks help, you clicked a Supplemental Software link at the bottom of the help home page. Then that help opened in a separate window.

For more information on the Upslope Area Toolbox sample and creating custom documentation, see builddocsearchdb and Display Custom Documentation.

New documentation reference pages for MathWorks products include an annotation at the bottom of the page. The annotation indicates the release in which the feature was introduced. For example, "Introduced in R2015a." (Some reference pages for features introduced before R2015a also include the release information.)

MATLAB limits the amount of computer memory used to allocate memory for each mxArray. To adjust or remove this limit, use the MATLAB array size limit preference described in Workspace Browser Preferences.

When editing class definition files in the Editor, you can press the Tab key to complete the names of class properties and methods. For more information, see Tab Completion.

For computers in Japanese, Chinese, or Korean locales, you can choose to run MATLAB with an English user interface rather than in the localized language. Desktop items (such as dialog boxes, button names, and menu items) and error and warning messages will appear in English. For information about setting this option, see General Preferences.

The repelem function copies elements of an array into a new array according to a specified repetition scheme.

The sort function now preserves the shape of input cell arrays of strings and sorts each column independently. This makes the behavior for sort with a cell array of strings consistent with the behavior of sort with a numeric array.

Compatibility Considerations

Previously, sort flattened all cell array of string inputs into a vector output. This behavior treated the input cell array as a tall vector of strings, and did not preserve the size of the input. Any code that relies on the output size of sort on a cell array of strings might need to be updated.

To continue using the previous behavior, use the colon operator, :, when calling sort on a cell array, for example, sort(X(:)).

The isenum function tests the input argument to determine if it is an enumeration.

The milliseconds function converts duration values to double values in units of milliseconds.

External file content can be added into MATLAB published code using the new <include> markup. For information about this new markup, see External File Content.

The fullfile function now maintains all double-dot symbols in the input file parts. This behavior is consistent with the treatment of double-dot symbols in R2012b and earlier.

In R2013a through R2014b, fullfile collapsed inner relative directories indicated by double-dot (..) symbols and returned an equivalent full file path specification that did not display the symbols. The double-dot symbols were maintained only if they appeared at either end of the full file path specification.

For example, the commands,

f = fullfile('C:\foo\folder1\..\folder2')
h = fullfile('\\folder4\.')

f =
C:\foo\folder1\..\folder2
h =
\\folder4\.

f =
C:\foo\folder2
h =
\\folder4\.

Compatibility Considerations

Change code that relies on resolving double-dot symbols in a full file path.

For more information, see:

• Accessing Elements in Python Container Types

• Limitations to Indexing into Python Objects

For examples, see:

• Index into Python String

• Index into Python list

• Index into Python tuple

• Index into Python dict

MATLAB supports the following versions of CPython:

• Version 2.7

• Version 3.3

• Version 3.4

For more information, see Install Supported Python Implementation.

The engine function matlab.engine.start_matlab supports MATLAB startup options. In addition, the engine supports '-desktop' to launch MATLAB with the desktop.

From Python 2.7 you can pass variables of data type unicode as input arguments to MATLAB functions. The engine can return unicode output arguments to Python 2.7.

In previous versions of MATLAB, the Java string was terminated at the first null.

When you communicate with web services using web services description language (WSDL) documents, errors can occur if a WSDL file imports another WSDL file that uses the WSDL import element. For more information, see Limitations to WSDL Document Support.

You can use tags to group tests into categories, and then run tests with specified tags. Tag your tests using the class-level or method-level TestTags attribute on TestCase. Select tagged test elements using the HasTag selector or the 'Tag' name-value pair on one of the following TestSuite methods: fromClass, fromFile, fromFolder, fromMethod, fromPackage, or selectIf. You also can select and run tagged tests using the 'Tag' name-value pair with the runtests function. For more information, see Tag Unit Tests.

You can run a suite of tests in parallel using the Parallel Computing Toolbox. For more information, see the runInParallel method of the TestRunner class.

You can include a shared variables section in your script-based test file. In this section you can define variables to share between tests in the script and define any critical preconditions necessary for your tests. For more information, see http://www.mathworks.com/help/releases/R2015a/matlab/matlab_prog/write-script-based-unit-tests.html.

You can manually configure your test environment, and the test runner does not need to perform shared fixture setup and teardown activities. To define prebuilt fixtures, use the PrebuiltFixtures property on the TestRunner instance in combination with the SharedTestFixtures attribute of the TestCase class. In certain testing scenarios, prebuilding fixtures can result in significant time or resource savings. An example where prebuilt test fixtures might be a benefit is a test that meets these three conditions:

• Has shared fixtures that are expensive to set up

• Has a required fixture state that can be set up manually in the MATLAB session

• Does not require a fresh test fixture for each test run

For more information, see matlab.unittest.TestRunner.

When the class of the expected value defines an isequaln method, the ObjectComparator uses that method for object comparison.

In previous releases, ObjectComparator used isequal to compare all objects. The IsEqualTo constraint and the assertEqual, assumeEqual, fatalAssertEqual, and verifyEqual qualification methods leverage ObjectComparator and, therefore, inherit the same change in behavior. For more information, see ObjectComparator.

Compatibility Considerations

Rewrite your tests to force a comparison with isequal when you use ObjectComparator to compare objects of a class that defines isequaln and you rely on the results of isequal instead of isequaln.

For example, if the class of expObj defines isequaln, then testCase.verifyEqual(actObj,expObj) uses isequaln for comparison, but testCase.verifyReturnsTrue(@()isequal(actObj,expObj)) uses isequal.

Similarly, testCase.verifyThat(actObj,IsEqualTo(expObj)) uses isequaln for comparison, but testCase.verifyThat(@()isequal(actObj,expObj),ReturnsTrue) uses isequal.

When you specify expected causes using the 'CausedBy' name-value pair argument in the Throws constraint, the causes must be a cell array of strings or an array of meta.class instances.

In previous releases, you specified the value of 'CausedBy' as a cell array that could contain both strings and meta.class instances. For more information, see matlab.unittest.constraints.Throws.

Compatibility Considerations

Rewrite tests that use the Throws constraint and specify heterogeneous data types for 'CausedBy'. If you cannot define expected causes using either a cell array of strings or an array of meta.class instances, consider performing the qualification using two separate Throws constraints.

When using the Git source control integration, you can view branch details and delete branches in the Manage Branches dialog box. Use the Branch Browser to see which files changed for a particular commit in the branch or to view the author, date, and commit message.

For more information, see Branch and Merge with Git.

The new functions mxCreateUninitNumericMatrix and mxCreateUninitNumericArray create numeric arrays without initializing the data elements. If you want to initialize the data elements, use the functions mxCreateNumericMatrix and mxCreateNumericArray.

To convert an mxArray to a C-style string in UTF-8 encoding, call the new mxArrayToUTF8String function.

To determine if an mxArray contains scalar data, call the new mxIsScalar function.

The discretize function groups numeric data into bins. By default the bins are numeric, and discretize returns indices describing the bin placement of each element. However, the bins also can be categories, in which case discretize returns a categorical array.

The following functions now have flags to include or omit NaN values in numeric computations: max, min, mean, median, sum, var, std, and cov.

The ismembertol and uniquetol functions perform set operations using a tolerance. These functions are useful in situations where floating-point round-off errors occur in calculations.

The dSFMT random number generator algorithm provides a faster implementation of the Mersenne Twister algorithm. For more information about available random number generator algorithms, see Creating and Controlling a Random Number Stream.

The nearestNeighbor function for alphaShape determines the nearest boundary point on the alpha shape for a specified query point.

The ReadSize property for TabularTextDatastore objects now accepts the string value, 'file'. This option reads one complete text file at a time. For more information, see TabularTextDatastore Properties.

The partition function partitions a datastore into a number of parts. You then can specify a subset of the datastore to read. If you have Parallel Computing Toolbox installed, you can read datastore parts in parallel without using MapReduce.

The webwrite function sends data to RESTful Web services using an HTTP POST request.

The webread and websave functions can request data using both HTTP GET and POST methods.

The xlsread and readtable functions can read larger spreadsheet files on Windows computers with Excel software installed.

As of R2014b, using the %q format specifier with the textscan and readtable functions returns consistent results. When using %q to read strings that begin with a double quotation mark ("), textscan and readtable remove the leading double quotation mark and its accompanying closing mark. The closing mark is the second instance of a lone, unescaped double quotation mark. The functions replace escaped double quotation marks (for example, ""abc"") with lone double quotation marks ("abc"). The textscan and readtable functions ignore any double quotation marks that follow the closing mark.

In R2014a and earlier, the textscan and readtable functions return unpredictable results when reading strings with extraneous double quotation marks. This behavior can occur when you use the %q format specifier or if you do not specify a value for the Format name-value pair argument to readtable.

For example, these commands:

C = textscan('"Alvin ""Al"" Smith"','%q','Delimiter',',');
C1 = C{:}
D = textscan('"Alvin" "Al" Smith"','%q','Delimiter',',');
D1 = D{:}
E = textscan('"Alvin ""Al"" Smith" and Brian"""Jones','%q','Delimiter',',');
E1 = E{:}

C1 = 
    'Alvin "Al" Smith'
D1 = 
    'Alvin "Al" Smith"'
E1 = 
    'Alvin "Al" Smith and Brian"""Jones'

In R2014a and earlier, the same commands return:

C1 = 
    'Alvin "Al" Smith'
D1 = 
    'Alvin "Al Smith"'
E1 = 
    'Alvin "Al" Smith and Brian""Jones'

Compatibility Considerations

Code that relies on using the %q format specifier to read text enclosed in double quotation marks might return different results. Such code includes calls to readtable that do not specify a value for the Format name-value pair argument. However, there is no behavior change when reading strings with proper double quotation marks.

This table lists upgrades to scientific file format libraries used by MATLAB.

Compatibility Considerations

The H5Pset_dxpl_multi and H5Pget_dxpl_multi routines were removed from the HDF5 Library as of version 1.8.11. As a result, the H5P.set_dxpl_multi and H5P.get_dxpl_multi functions in MATLAB now return an error. Remove instances of H5P.set_dxpl_multi and H5P.get_dxpl_multi from your code.

drawnow now supports the limitrate option for limiting the number of figure updates to 20 frames per second. If you are updating graphics objects in a loop and do not need to see every update on the screen, you can use this option to skip some updates for a faster animation.