In order to call compiled MATLAB® functions from within a Microsoft® Excel® spreadsheet, perform the following from the Development and Deployment machines, as specified.
Note:
In order for a function to be called using the Microsoft Excel function
syntax ( |
Perform the following steps on the Development machine:
Create the following MATLAB functions in three
separate files named doubleit.m
, incrementit.m
,
and powerit.m
, respectively:
function output = doubleit(input) output = input * 2;
function output = incrementit(input1, input2) output = input1 + input2;
function output = powerit(input1, input2) output = power(input1, input2);
Start the Library Compiler.
Use the following information as you work through this example using the instructions in Package Excel Add-In with Library Compiler App:
Application Name | myexcelfunctions |
Class Name | myexcelfunctionsclass |
Exported Functions |
|
Perform the following steps on the Deployment machine:
Copy the contents of for_redistribution_files_only
to
the deployment machine(s). Copy the file to a standard place for
use with Microsoft Excel, such as
where Office_Installation_folder
\Library\MATLABOffice_Installation_folder
is
a folder such as C:\Program Files\Microsoft Office\OFFICE11
.
Install the MATLAB Runtime.
Register myexcelfunctions_1_0.dll
.
Caution You need to re-register your DLL file if you move it following its creation. Unlike DLL files, Excel files can be moved anywhere at anytime. |
Start Microsoft Excel. The spreadsheet Book1
should
be open by default.
In Excel, select Tools > Visual Basic Editor. The Microsoft Visual Basic® Editor starts.
In the Microsoft Visual Basic Editor, select File > Import File.
Browse to myexcelfunctions.bas
and
click Open. In the Project Explorer, Module1 appears
under the Modules node beneath VBAProject
(Book1).
In the Microsoft Visual Basic Editor, select View
> Microsoft Excel. You can now use the doubleit
, incrementit
,
and powerit
functions in your Book1 spreadsheet.
Test the functions, by doing the following:
Enter =doubleit(2.5)
in cell A1.
Enter =incrementit(11,17)
in cell
A2.
Enter =powerit(7,2)
in cell A3.
You should see values 5, 28, and 49 in cells A1, A2, and A3 respectively.
To use the doubleit
, powerit
,
and incrementit
functions in all your new Microsoft Excel spreadsheets,
do the following:
Select File > Save As.
Change the Save as type option to .xlt (Template).
Browse to the
folder.Office_Installation_folder
\XLSTART
Save the file as
.Office_Installation_folder
\XLSTART\Book.xlt
Note: Your Microsoft Excel Macro Security level must be set at Medium or Low to save this template. |
See Example File Copying for information about accessing the example code from within the product.
This feature provides a lightweight interface for easily accessing
the MATLAB Runtime data. It allows data to be shared between the MATLAB Runtime instance,
the MATLAB code running on that the MATLAB Runtime, and the
wrapper code that created the MATLAB Runtime. Through calls to
the MATLAB Runtime User Data interface API, you access the MATLAB Runtime data
by creating a per MATLAB Runtime instance associative array of mxArray
s,
consisting of a mapping from string keys to mxArray
values.
Reasons for doing this include, but are not limited to:
You need to supply run-time profile information to a client running an application created with the Parallel Computing Toolbox™. Profile information may be supplied (and change) on a per-execution basis. For example, two instances of the same application may run simultaneously with different profiles.
You want to initialize the MATLAB Runtime with constant values that can be accessed by all your MATLAB applications.
You want to set up a global workspace — a global variable or variables that the MATLAB and your client can access.
You want to store the state of any variable or group of variables.
MATLAB Compiler™ supports per the MATLAB Runtime instance
state access through an object-oriented API. Unlike MATLAB Compiler,
access to per the MATLAB Runtime instance state is optional, rather
than on by default. You can access this state by adding setmcruserdata.m
and getmcruserdata.m
to
your deployment project or by specifying them on the command line.
Alternately, you use a helper function to call these methods, as shown
in Supply Run-Time Profile Information for Parallel Computing Toolbox Applications.
For more information, see the MATLAB Compiler User's Guide.
Following is a complete example of how you can use the MATLAB Runtime User Data Interface as a mechanism to specify a profile for Parallel Computing Toolbox applications.
Note: Standalone executables and shared libraries generated from MATLAB Compiler or MATLAB Compiler SDK™ for parallel applications can now launch up to twelve local workers without MATLAB Distributed Computing Server™. |
Step 1: Write Your Parallel Computing Toolbox Code.
Compile sample_pct.m
in MATLAB.
This example code uses the cluster defined in the default profile.
The output assumes that the default profile is local
.
function speedup = sample_pct (n) warning off all; tic if(ischar(n)) n=str2double(n); end for ii = 1:n (cov(sin(magic(n)+rand(n,n)))); end time1 =toc; parpool; tic parfor ii = 1:n (cov(sin(magic(n)+rand(n,n)))); end time2 =toc; disp(['Normal loop times: ' num2str(time1) ... ',parallel loop time: ' num2str(time2) ]); disp(['parallel speedup: ' num2str(1/(time2/time1)) ... ' times faster than normal']); delete(gcp); disp('done'); speedup = (time1/time2);
Run the code as follows after changing the default
profile to local
, if needed.
a = sample_pct(200)
Verify that you get the following results;
Starting parallel pool (parpool) using the 'local' profile ... connected to 4 workers. Normal loop times: 0.7587,parallel loop time: 2.9988 parallel speedup: 0.253 times faster than normal Parallel pool using the 'local' profile is shutting down. done a = 0.2530
Step 2: Set the Parallel Computing Toolbox Profile. In order to compile MATLAB code to a COM component and
utilize the Parallel Computing Toolbox, the mcruserdata
must
be set directly from MATLAB. There is no API available to access
the MCRUserdata
as there is for C and C++ applications
built with MATLAB Compiler.
To set the mcruserdata
from MATLAB,
create an init
function in your COM class. This
is a separate MATLAB function that uses setmcruserdata
to
set the Parallel Computing Toolbox profile once. You then call
your other functions to utilize the Parallel Computing Toolbox functions.
Create the following init
function:
function init_sample_pct % Set the Parallel Profile: if(isdeployed) [profile] = uigetfile('*.settings'); % let the USER select file setmcruserdata('ParallelProfile',[profile]); end
Step 3: Compile Your Function with the Deploytool or the Command Line. You can compile your function from the command line by entering the following:
mcc -B 'cexcel:exPctComp,exPctClass,1.0' init_sample_pct.m sample_pct.m
Alternately, you can use the deploytool as follows:
Follow the steps in Package Excel Add-In with Library Compiler App to compile your application.
When the compilation finishes, a new folder (with the same name as the project) is created.
Project Name | exPctComp |
Class Name | exPctClass |
File to compile | sample_pct.m and init_sample_pct.m |
Note: If you are using the GPU feature of Parallel Computing Toolbox, you need to manually add the PTX and CU files. If you are using the Library Compiler app, click Add files/directories on the Build tab. If you are using the |
To deploy the compiled application, copy the for_redistribution_files_only
folder,
which contains the following, to your end users.
exPctComp.dll
VBA module (.bas
file)
Cluster profile
Note: The end-user's target machine must have access to the cluster. |
Step 4: Modify the generated VBA Driver Application (the BAS File). After registering the COM DLL on the deployment machine and importing the BAS file into Excel, modify the generated BAS file code as needed.
Dim MCLUtil As Object Dim bModuleInitialized As Boolean Dim exPctClass As Object Private Sub InitModule() If Not bModuleInitialized Then On Error GoTo Handle_Error If MCLUtil Is Nothing Then Set MCLUtil = CreateObject("MWComUtil.MWUtil7.10") End If Call MCLUtil.MWInitApplication(Application) bModuleInitialized = True Exit Sub Handle_Error: bModuleInitialized = False End If End Sub Function init_sample_pct() As Variant On Error GoTo Handle_Error Call InitModule If exPctClass Is Nothing Then Set exPctClass = CreateObject("exPctComp.exPctClass.1_0") End If Call exPctClass.init_sample_pct init_sample_pct = Empty Exit Function Handle_Error: init_sample_pct = "Error in " & Err.Source & ": " & Err.Description End Function Function sample_pct(Optional pelle As Variant) As Variant Dim speedup As Variant On Error GoTo Handle_Error Call InitModule If exPctClass Is Nothing Then Set exPctClass = CreateObject("exPctComp.exPctClass.1_0") End If Call exPctClass.sample_pct(1, speedup, pelle) sample_pct = speedup Exit Function Handle_Error: sample_pct = "Error in " & Err.Source & ": " & Err.Description End Function
The output is as follows:
deployable archive data is automatically embedded directly in MATLAB Compiler components by default and extracted to a temporary folder.
Automatic embedding enables usage of MATLAB Runtime Component Cache features through environment variables.
These variables allow you to specify the following:
Define the default location where you want the deployable archive to be automatically extracted
Add diagnostic error printing options that can be used when automatically extracting the deployable, for troubleshooting purposes
Tuning the MATLAB Runtime component cache size for performance reasons.
Use the following environment variables to change these settings.
Environment Variable | Purpose | Notes |
---|---|---|
MCR_CACHE_ROOT | When set to the location of where you want the deployable archive to be extracted, this variable overrides the default per-user component cache location. | Does not apply |
MCR_CACHE_VERBOSE | When set to any value, this variable prints logging details about the component cache for diagnostic reasons. This can be very helpful if problems are encountered during deployable archive extraction. | Logging details are turned off by default (for example, when this variable has no value). |
MCR_CACHE_SIZE | When set, this variable overrides the default component cache size. | The initial limit for this variable is 32M (megabytes). This
may, however, be changed after you have set the variable the first
time. Edit the file .max_size , which resides in
the file designated by running the mcrcachedir command,
with the desired cache size limit. |
You
can override this automatic embedding and extraction behavior by compiling
with the -C
option. See Overriding Default Behavior for details.
Note:
If you run mcc -W lib:myLib -T link:exe test.m test.c test.exe will not have the deployable
archive embedded in it, as if you had specified a -C option
to the command line. |
Caution
Do not extract the files within the |
To extract the deployable archive in a manner prior to R2008b,
alongside the compiled COM component, compile using the mcc
-c
option.
You can also implement this override by adding the -c
flag
in the Settings section of the compiler app.
You might want to use this option to troubleshoot problems with the deployable archive, for example, as the log and diagnostic messages are much more visible.
For more information about the deployable archive, see Deployable Archive.
-logfile
— Creates a named
log file.
If You Compiled the Add-In in MATLAB or used mcc. If you are building your add-in using the MATLAB Library Compiler, select Create log file under Additional Runtime Settings.
If you are building your add-in using mcc
,
simply specify -logfile
with the mcc
-R
command
If You Created a Function From Scratch Using the Function Wizard. If you created a function from scratch using the Function Wizard,
and want to specify MATLAB Runtime options, you have to manually
modify the .bas
file code.
You do this by invoking the following MWUtil
API
calls, detailed with examples in Class MWUtil: