Installation

Installing DADiSP 6.5 for Windows 7/9x/2000/NT/XP and Vista

Place the CD into the disk drive. From the Windows Start Bar, click RUN then type:

D:SETUP

where D: is the name of the drive with the DADiSP installation disk.

The installation procedure will prompt for a destination drive and directory for DADiSP. Follow the instructions on the screen.

The installer automatically registers .dsp .mac, .men, .hed, .pan, .tab and .spl file extensions. This allows NotePad to treat these files as ASCII text.

The installer also registers the various ActiveX capabilities of DADiSP.

See Installation Notes for more details about the installation process for both Stand-Alone and Network licenses.

New Features

DADiSP 6.5 B01 Release Notes

DADiSP 6.5 includes a number of exciting new features and enhancements. The majority of these changes and improvements are the direct result of customer requests and interaction.

New Stripchart Facility

DADiSP 6.5 supports the display and processing of multi-column data plotted like a familiar stripchart recorder. Properties such as trace color, axes placement and color attributes are easily specified. Calculations on a stripchart extend to each trace and automatically yield a corresponding output stripchart. Load entire Datasets or any combination of individual Series into one or more stripchart views.

Integrated MATLAB® Code Execution

The DADiSP MATLINK Module (included in DADiSP 6.5) provides a seamless interface for executing MATLAB code directly from DADiSP. DADiSP 6.5 processes any built-in or custom MATLAB functions or scripts just as if they were native DADiSP functions. MATLAB and DADiSP functions can be freely mixed and DADiSP 6.5 immediately plots series and array results from MATLAB. MATLAB Code Execution MATLINK hot-links MATLAB code inside a DADiSP Worksheet such that dependent functions automatically update in response to source data changes.

Extended Graphic Objects and Manipulation

Enhanced rectangle, ellipse, polyline, polygon and text objects offer improved custom annotation capabilities to any data plot. Set text or shape properties with a mouse click. A powerful object-handle interface allows programmatic manipulation of any text or shape annotation.

Visual Data Editing

Visual Editing A mouse-based data editing and clipping facility supports freehand visual editing of any data Series. Manually remove outilers or edit specific sections of data with pen-like mouse movements and optionally limit data to a visually specified clipping line or clip box.

SPL Extensions

DADiSP 6.5 extends SPL, DADiSP’s Series Processing Language, to provide both function and file based static and global variables. A new form based custom dialog box facility enables the inclusion of GUI specifications and related SPL functions in one combined file. SPL’s C/C++ syntax offers a familiar and clean programming style allowing users to create SPL Debugger custom functions and procedures using standard programming techniques.

Integrated SPL Debugger

DADiSP 6.5 provides a source-level, GUI based debugger to simplify the development of custom SPL functions and routines. The debugger offers one-click source line stepping and variable examination, on-the-fly expression evaluation and variable assignments, function and line based breakpoints, call stack manipulation and color coded syntax highlighting of SPL source files.

Expanded Documentation

The DADiSP 6.5 Function Reference has been significantly expanded and enhanced. Examples from the on-line help files can be cut and pasted directly into a DADiSP Worksheet for immediate evaluation. Mathematical background information and algorithm details are provided for many functions and routines.

Updated Dataset and Series GUI

Load Series Dialog Box Streamlined Dataset and Series interface allows any Dataset or combination of Series to be loaded into separate Windows or into a single Window as a multi-channel stripchart. Easily examine Series properties and select target Windows and stripchart plotting options from a uniform GUI.

Improved Hardcopy

DADiSP 6.5 automatically adjusts the Worksheet or Window for maximum utilization of a printer’s graphics capabilities. Add Worksheet title and footer labels to further annotate output results. Specify plot attributes such as color, margin alignment, borders and text justification through simple Print Preview dialogs.

And 100+ New Functions

DADiSP 6.5 includes over 100 new built-in and SPL routines spanning the areas of matrix and series manipulation, signal processing, math, color, series generation, curve fitting and statistics. DADiSP 6.5 now offers over 1000 analysis routines with an intuitive and familiar user interface to provide one of the most comprehensive and easy to use data analysis tools available today.

New Functions

Over 100 new functions have been added to DADiSP 6.5. Full descriptions of the functions listed here are included in the on-line help system.

MATLINK

MATLAB Code Execution Module

MATLINK runs MATLAB programs directly from DADiSP and exchanges data between DADiSP and MATLAB. Both built-in and custom MATLAB functions or scripts are executed just as if they were native DADiSP functions.

Arrays, scalar and string data are exchanged transparently in fast binary format using the ActiveX Automation interfaces of DADiSP and MATLAB.

How Does It Work?

The key to the simplicity and power of MATLINK resides in the MATLAB Object created by DADiSP. The MATLAB Object supports the execution of any MATLAB expression from the MATLAB environment and returns the results to DADiSP via ActiveX. Because the code is still run in MATLAB, the results are exactly the same as would normally be produced by MATLAB.

ML Dot Syntax

The default name of the MATLAB Object is ml. Simply preface the original MATLAB function name with ml. to run any MATLAB code from DADiSP. For example, the following DADiSP command displays the current version of the available MATLAB release:

ml.version

Mix and Match
DADiSP and MATLAB functions can be combined and used interchangeably within a Worksheet or SPL functions. For example:

W1: gnorm(10000, 1)
W2: ml.diff(W1)

W1 contains 1000 samples of Gaussian distributed random noise. The data is then processed by the MATLAB diff function and displayed in W2. When W1 changes, W2 automatically updates and the new data is processed by MATLAB.

The MATLAB difffunction executes just like any other DADiSP function except

1. DADiSP sends the required data to MATLAB.
2. MATLAB executes the function.
3. The results are returned to DADiSP.

The entire process is perfomed automatically, transparently and efficiently.

DADiSP and MATLAB functions can be freely mixed. For example:

W1: gnorm(10000, 1)
W2: movavg(ml.diff(w1), 10)

The MATLAB diff function is applied to the data in W1 and the result is smoothed by means of a 10 point moving average computed by the DADiSP movavg function. Any combination of DADiSP and MATLAB functions can be combined in this manner.

Data Exchange
Although generally not required, MATLINK supports explicit data exchange between DADiSP and MATLAB variables. For example:

// assign a DADiSP series to a MATLAB variable
  ml.MatVar = 1..100;

  // return a MATLAB variable to DADiSP and process
  x = 10 * ml.MatVar;

The MATLAB variable MatVar is created and assigned a series of values from 1 to 100. The DADiSP variable x contains the value of the MATLAB variable multiplied by 10. Though required data transfers are automatically handled by the MATLAB Object, the “dot syntax” provides a natural method for exchanging program variables when desired.

MATLAB Command Prompt
MATLAB expressions in original MATLAB syntax are evaluated directly by using the > prompt.

W1: >1:100
W2: integ(W1)

W1 contains the values 1 through 100 as produced by the MATLAB expression 1:100. W2 integrates the data. Again, a change to W1 automatically updates W2.

Although the equivalent data in W1 can be generated natively by DADiSP with the statement 1..100, the expression 1:100 is standard MATLAB syntax. Any expression in standard MATLAB syntax is supported and evaluated when the expression is prefaced by the > prompt.

Additional Features
The mlhelp function displays the original help text for MATLAB functions. For example:

mlhelp eig

The standard help information for the MATLAB eig function is displayed in DADiSP.

The mldoc function displays the online documentation for MATLAB functions. For example:

mldoc fft

The online documentation for the MATLAB fft function is displayed in DADiSP.

Multiple return values from MATLAB functions is supported.

W1: rand(10)
W2: (v, d) = ml.eig(W1);d

The MATLAB eig function returns two arrays. The second array, a diagonal matrix of eigenvalues, is placed and dislayed in W2.

Error messages or warnings produced by MATLAB are displayed in DADiSP. Functions that produce textual results are presented in a pop-up dialog box. For example, to display a list of currently available MATLAB variables with corresponding data types:

ml.whos

The mlshow function displays or hides the MATLAB automation server.

mlshow(1)

displays the MATLAB automation server user interface.

Requirements
MATLINK requires a licensed copy of MATLAB Version 4.0 or higher to be available from the machine running DADiSP.

GUI Enhancements

Legend and Arrow Drawing
The drawing toolbar now supports legends and arrows. Selection and configuration buttons have been added.

Text, legends, lines and arrows can be directly selected and manipulated with the mouse when the Window is activated or zoomed.

Date and Time Configuration
A Date/Time tab has been added to the Tools-Options-System Preferences dialog to configure data/time display of series in a Window.

Tic Mark Configuration
The Window tab of the Tools-Options-System Preferences dialog includes an “Autoscaling Mode” option. “Peak Centering” centers the data in the Window based on the extreme values and “Tic Marks” autoscales the Window such that a tic mark always occurs at the bottom and top of the Window.

User Defined Default Units
“Default Horizontal Units” and “Default Vertical Units” have been added to the Series tab of the Tools-Options-System Preferences dialog to set the default units of generated series.

Global Color Configuration
“Global Colors” in the Tools-Options-Settings dialog are now saved in the session file so color settings are now preserved. The colors of the Window caption is now configurable in the Tools-Options-Settings dialog.

Full Dataset Display
Open Dataset supports loading an entire Dataset into one window with each series drawn in a different color. The attributes of these series can be manipulated in the Properties dialog.

Metafile and Clipboard Configuration
The Tools-Options-Print Preferences-Metafile dialog supports configuration of the clipboard formats. This can optimize clipboard transfers if the desired format of the data or image is known beforehand.

Circular Calculation Configuration
The Tools-Options-Settings-Calculations dialog supports configuration of Recursive Window Formulae. Recursive formulae involve Windows that depend on each other to create a dependency cycle. The number of evaluations per cycle can be specified.

Window Tiling
Worksheets can be tiled vertically, horizontally, equal sized and automatically. Custom Window layouts can also be specified.

Send Worksheet via Email
The File-Send menu option uses the default MAPI settings to send a Worksheet as an email attachment. The recipient can double click the received attachment to automatically view the Worksheet if a full version of DADiSP or the browser version of DADiSP is installed on the recipient’s machine.

To configure Outlook Express as your default MAPI client, select the “Make Outlook Express my Simple MAPI client” check box under the Tools-Options menu.

Most Recently Used Dialog Box History
The Right Click menu now includes a list of the most recently used dialog boxes. This history allows for quick selection of the most often used dialogs. The number of dialog boxes displayed can be configured with the Tools-Options-System Preferences-Misc dialog.

Window Dependency Display
The dependencies of the current Window can be displayed with the Tools-Options-System Preferences-Screen Elements dialog. When selected, the captions of the Windows the current Window depends on (“parents”) and the Windows that depend on the current Window (“children”) are displayed in different colors. The colors can also be configured with the Tools-Options-System Preferences-Screen Elements dialog.

Tabular Display Configuration
TableView supports multiple header lines. Header lines can be configured with the Tools-Options-System Preferences-Table dialog. A column header can optionally contain a column number, series name, series comment and/or units.

Cursor Mouse Selection
Data cursors can be graphically selected by left clicking on or near the desired cursor. Cursor styles are set with the View-Cursor-Settings dialog.

Automatic Dataset Display
File-Open-Dataset-Multiple Windows will prompt to automatically add the correct number of Windows if the Dataset contains more series than the number of consecutive Windows.

SPL Debugger

The debug or db commands start the SPL debugger and set a breakpoint in the specified function. For example, following debug session:

db roots
roots(1..5)

invokes the SPL Debugger and sets a breakpoint in the roots function. The Command Line will display a red prompt background to indicate debug mode.

Since the roots function is called, the debugger will display the source code and pause at the first executable line. Use the GUI interface to step through code, set breakpoints and evaluate expressions. Click on any variable to display its value.

Because a breakpoint has been set in the roots function, the debugger will pause whenever roots is called. For example, invoking the residuez function through the pull down menus:

Analysis » Signal Processing » Partial Fraction Expansion

causes the debugger to stop in roots because residuez calls roots.

Use the appropriate debugger buttons to step through and into SPL functions, move up and down the stack and show the function call sequence.

Examining Variables
Use the debugger command prompt to examine global and local variables by entering the variable to examine or simply click on any variable to view its current value in the output display area.

Setting Breakpoints
Press the Breakpoints button or use the db function to set additional break points in SPL routines and to set a break point at a specific line number.

Clicking the left mouse button in the left margin of a line also sets a new breakpoint or clears an existing breakpoint.

SPL Enhancements

Static Variables
Static variables are persistent from one call of a function to another. Static variables can be local to a particular function or local to all functions within particular SPL file. A static variable behaves like a local variable in that variable is only accessible to the function that declares the static variable or if file based, to the functions declared within the same file.

For example:

 sumval(x)
  {
      static sum = 0;

      sum += x;

      return(sum);

  }

The function sumval returns the sum of the current input value and all previous values. The static variable sum behaves like a local variable except it is persistent from one call to sumval to another.

Static variables can be file based such that all functions within the same SPL file have access to the variable.

// sumval.spl

  static sum = 0;

  sumval(x)
  {
      sum += x;
      return(sum);
  }

  currsum()
  {
      return(sum);
  }

In this case, sumval behaves identically to the previous example and currsum returns the current sum.

File Based Global Variables
Global variables can be specified on a file basis.

// myfun1.spl

  extern a = 10;
  extern b = 20;

  myfun1()
  {
      return(b);

  }

  myfun2(x)
  {
      a = x;
      b = a * a;
  }

  c1 = myfun1();

  c1 == 20;

  myfun2(5);

  a == 5;
  b == 25;

  c2 = myfun1();

  c2 == 25;

Variables a and b are global variables accessible to both functions myfun1 and myfun2. File based external variables are initialized when the SPL function is first loaded, whether automatically loaded or explicitly loaded.

Custom Dialog Forms
The @form and @endform keywords enable custom dialog box templates to directly embed related SPL code in the same file. For example, the following dialog generates a random series with user defined length and delta X values:

// test.pan - form based dialog
  @panel
  @form

  // default initial length and deltax if not defined
  {defvar("_form_dlen", 1000)}
  {defvar("_form_dx",   0.01)}

  Test Menu

  // get integer value, "%" sets value immediately
  Length: <% w{25}>~_form_dlen = <{_form_dlen}>~input(2)

  // get real value, "%" sets value immediately
  DeltaX: <% w{25}>~_form_dx   = <{_form_dx}>  ~input(1)
  <L>

  // generate data when OK pressed
  ~form_gendata(_form_dlen, _form_dx)

  @endform

  // SPL code

  form_gendata(len, dx)
  {
      // format and set the current window formula
      eval(sprintf("W0 := gnorm(%d, %g)", len, dx));
  }

The above form creates the following custom dialog box:

When the OK button is pressed, the embedded form_gendata() function executes and produces a formula in the current window based on the input values.

gnorm(1000, 0.001)

Any SPL code can be embedded in the form after the @endform statement.

New @@ Concatenate Operator
a = b @@ c is more compact and equivalent to a = concat(b, c)

New @= Append Operator
a @= b is equivalent to append(a, b). The @= operator appends the series b to the end of series a in place. a @= b is much faster than a = a @@ b for large series because @= operates on the existing series whereas @@ creates and assigns a new series.

Compatible Operators
The .* scalar multiply ./ scalar divide and .’ real transpose operators are supported for convienence with legacy M file code.

Shapes and Text

DADiSP 6.5 includes enhanced rectangle, ellipse, polyline, polygon and text objects. Shape and text objects can be generated from the toolbar or created programatically. The following annotation capabilities are available:

1. Updated “Drawing Toolbar” supports rectangle, ellipse and polygon filled or transparent shape creation.
2. Full dialog based text, shape and line property editing.
3. Add Worksheet Title and/or Footer Text.
4. Associate arbitrary text tags with any shape or line.
5. Reference text, shapes or lines by an object handle. Object handles can get or set object properties using a simple handle.property syntax. For example:

// generate a line
  1..100;

  // add text to plot
  handle = text(10.0, 20.0, "My Text");

  color = handle.color;         // get object color
  handle.color = lred;          // set color to light red
  handle.text = "Example Text"; // set object text

This example draws a rectangle in a Window and uses the object handle to set the color, width and fill color of the rectangle.

W1: gsin(100,.01);
  h = rectdraw(W1, 0.2, -0.5, 0.6, 1.0);
  h.color = lred; h.width = 4;h.fill = yellow;

6. Find any object based on property values. For example:

 h = findhandle(W1);

returns an array of handles to all the text, line or shape objects in W1.

h = findhandle(W1, "color", lred);

returns an array of handles to all the text, line or shape objects in W1 with a color of light red.

h = findhandle(W1, "color", lred, "shape", "ellipse");
h.fill = lgreen;

returns an array of handles to all the ellipse objects in W1 with a border color of light red and then sets the interior colors of those objects to light green. Any combination of property values can be specified to locate objects.

The findtext function searches for text objects only and findshape searches for shapes and lines only.

ActiveX Enhancements

REGISTEREVENT Handles Incoming ActiveX Events
REGISTEREVENT assigns an SPL function to execute when an external AciveX event is fired.

Consider the following SPL event handler:

/* simple event handler */
  MyEvent(argv)
  {
      local i, str = "";

      loop (i = 1..argc)
      {
          str += sprintf("arg%d: %s ", i,
                      caststring(getargv(i)));
      }
      message("MyEvent", str);
  }

The handler can be used to process events from Internet Explorer.

 /* connect to Internet Explorer */
  ie = createobject("internetexplorer.application");

  /* navigate to home page */
  ie.navigate("www.dadisp.com");

  /* show it */
  ie.visible = 1;

  /* establish event handler */
  registerevent(ie, "TitleChange", "MyEvent");

Each time the title displayed by Internet Explorer changes, MyEvent is called and a message box is displayed.

The event can also be specified by an integer event ID. For example:

registerevent(ie, 0x71, “MyEvent”);

UNREGISTEREVENT removes and SPL event handler.

FIREEVENT and RAISEEVENT Fire Outgoing ActiveX Events
FIREEVENT fires an ActiveX event with id numbers 1 through 8. Zero or more arguments can be passed to the event handler. The arguments are passed as a standard automation array of variants suitable for most automation or script languages.

The following is an example of an event handler in VBA.

Public WithEvents DSP As DADiSPApp

  ''' initialize server
  Sub InitDSP()

      Set DSP = New DADiSPApp
      DSP.Visible = True

  End Sub

  ''' handler for event 3
  Sub DSP_Event03(ParamArray args() As Variant)
      Dim i As Integer
      Dim s As String

      s = ""
      For i = 0 To UBound(args)
          s = s + CStr(args(i))
      Next i

      MsgBox s, vbOKOnly, "Event 3 Fired"

  End Sub

To properly setup the event handler, add a Reference to the DADiSP Type Library.

In DADiSP, executing the statement:

fireevent(3)

causes the DSP_Event03 VBA code to execute and display a message box.

The statement:

fireevent(3, "test", 2.5)

causes the DSP_Event03 VBA code to execute and display the text:

test 2.5

RAISEEVENT uses id number 9 through 16 and provides the optional arguments as a SafeArray of variants suitable for .NET languages.

GETCONTROL Returns the Current ActiveX Object
An SPL event handler can retrieve the handle to the calling ActiveX control or server with GETCONTROL.

Consider the following SPL event handler:

/* simple event handler */
  MyEvent(argv)
  {
      local i, str = "";

      loop (i = 1..argc)
      {
          str += sprintf("arg%d: %s ", i,
                      caststring(getargv(i)));
      }

      /* get calling ActiveX object */
      ctrl = getcontrol();

      /* display status text and title */
      message(ctrl.StatusText, str);
  }

The handler can be used to process events from Internet Explorer.

/* connect to Internet Explorer */
ie = createobject("internetexplorer.application");

/* navigate to home page */
ie.navigate("www.dadisp.com");

/* show it */
ie.visible = 1;

/* establish event handler */
registerevent(ie, "TitleChange", "MyEvent");

Each time the title displayed by Internet Explorer changes, MyEvent is called and a message box is displayed. The message box displays the status line text and the current title of the displayed web page.

Calculate Method
Calculate accepts a variable number of arguments from an ActiveX client.

Visual Basic Example:

Dim DADiSP as Object
  Dim val as Variant

  ''' Connect to DADiSP
  Set DADiSP = CreateObject("dadisp.application")

  ''' Create a 2 Window Worksheet without prompting
  Call DADiSP.Execute("Newworksheet(2, 0)")

  ''' Generate 10x3 random array, return result as a variant
  val = DADiSP.Calculate("rand", 10, 3)

Starts DADiSP as an ActiveX Automation server, creates a 2 Window Worksheet, returns a 10×3 random array by processing the input arguments.

The placement of the arguments can be specified with the $ character.

Visual Basic Example:

Dim DADiSP as Object

  ''' Connect to DADiSP
  Set DADiSP = CreateObject("dadisp.application")

  ''' Create a 2 Window Worksheet without prompting
  Call DADiSP.Execute("Newworksheet(2, 0)")

  ''' Generate a scaled 100 point random series with formula
  Call DADiSP.Calculate("W1 := gnorm($1, 1)*$2", 100, 10)

Starts DADiSP as an ActiveX Automation server, creates a 2 Window Worksheet and places a 100 point random series in W1 scaled by 10 with a formula. The positions of the input arguments are specified by the placeholder variables $1 and $2.

Configuration

Configuration
DADiSP 6.5 automatically detects if it is running under Vista or higher and configures the Labbook and temporary file layout to conform to security protocols. The AUTOCONFIG function can be used to provide the same secure layout for Windows XP and lower.

The following is an example of a typical layout where username is the login name of the current user.

1. Executable and Program Files

C:Program Filesdsp65

2. Labbooks

C:Documents and SettingsusernameMy DocumentsDADiSP

3. Session File

C:Documents and SettingsusernameApplication DataDADiSPdadisp6.ses

4. OPL Files

C:Documents and SettingsusernameApplication DataDADiSP

5. Temporary Files (Spill Files)

C:Documents and SettingsusernameLocal SettingsTemp

Help Engine
Note that Windows 7 and Vista do not include the standard help engine for 32-bit help files used by DADiSP. However, you can download the help engine directly from Microsoft.

• Download winhlp32.exe for Windows 7
• Download winhlp32.exe for Vista

Command Line Arguments

DADiSP supports the -s command line argument to automatically load and run an SPL file on startup. For example:

dadispnt -s=process.spl

starts DADiSP, loads the file process.spl and runs the SPL function process().

DADiSP supports the -d command line argument to specify the initial display mode:

-d=0  - hidden
-d=1  - normal
-d=2  - maximized
-d=3  - iconic

Running DADiSP in hidden mode (-d=0) is useful when using DADiSP as an analysis engine in conjunction with another program.

Additional command line arguments include:

 -l=labbookpath   - open a specific Labbook
 -w=worksheet     - open a specific Worksheet
 -cnf=configfile  - load a session specific config file
 -register        - register as an ActiveX server
 -unregister      - unregister as an ActiveX server