Display matrices in a grid and draw charts from variables from within the debugger

Delphi debugger

MtxVec for Delphi does a lot of work with arrays and the following object types: TVec, TVecInt, TMtx, TMtxInt, Vector, Matrix, VectorInt, MatrixInt. It can be of great help, if the contents of arrays and objects could be examined during debug time without the need to write special code to either store the variable contents to disk or display on screen. The Delphi debugger displays only array sizes up to 132768 elements and for numerical applications such sizes can be slow to examine and much too little. That is why debugger array visualizers are provided with MtxVec.

In our own expirience, such additional insight can make some problems, previously thought unsolvable, solvable. It helps with short term memory of the programmer making more information avialable concurrently and some data manipulations can only be understood and checked by charting it. This avoids the need for dedicated test software development in order to check every stage of the algorithm, thus providing great productivity boost. The visualizers are fine-tuned for numerical application development and can also be used with great success with projects not using MtxVec. Many our users skeptical about usefulness of such a tool, later discovered it to be indispensible.

The initial version released in 2009 supported Delphi since version 2006. Full IDE integration became available from Delphi 2010. A  completely reworked visualizer was launched in 2024. Our visualizers deliver superior speed and responsiveness not interfering with the normal debugging process.

MtxVec plug-in for Delphi debugger

Debugger Visualizer allows the user to display content of variables while debugging within Embarcadero RAD Studio IDE. This is most useful for arrays, vectors and matrices, which can be displayed on the grid and on the charts. Additionally, a powerful scripting engine allows manipulation of the content of the variables to extract statistics and manipulate the display of the content of the variables. Key features:

• Natively supports Delphi arrays and MtxVec Vector, Matrix, VectorInt and MatrixInt types.
• All variables added to the visualizer are now accessible from all opened visualizer windows. This allows:

• multiple windows with different views of the same variable without doubling or tripling the memory usage
• You can write expressions and script in any of the windows with access to all vars.

• Support for pinning will track variable content based on address (pointer value) rather than var name. This allows you to follow content while stepping into functions and methods also:

         a.) without the need to rename the var and

        b.) when the variable name or expression cannot be directly evaluated by the debugger.

• Three modes of operation, Single variable X, Expression f (x), and Script. All three are selectable with the toolbar buttons. Depending on which one is selected, the computation will be updated once you press F7/F8 or stop at a debug point.
• If you right click the debugged variable in the visualizers list of debugger vars, you can make a copy to a global var. This global var will persist between runs and between visualizer windows. You can write script referencing these global var.
• Var list items and “Global var list”, which will include also var values, will persist between runs and project sessions. You can continue working on the collected data, while the app is still running and switch to debugging as soon as you need to collect something new.
• Map also integers, double, single and boolean values and strings to the visualizer. Scalars, not only vectors and matrices. These scalars can then participate in expressions and the script.
• Add any value to visualizer by pressing CTRL+F6 with your (keyboard) cursor in it within the Delphi code editor, or simply type the name in to the var name box of the visualizer and press enter. Even if the var is not recognized, it will be added to the list and updated the first time it is found to exist.
• The speed and memory usage have been greatly optimized. For example, the visualizer is no longer trying to detect the type of variable on every update.
• When a variable is out of scope, you get “Undefined” written in the list of values, rather than old or spurious values or a crash.
• The new string visualizer allows you to load 100MB long strings. (limited by available memory).
• To view any var data simply double click the var in the table.
• You can avoid auto-scroll when the var is updated in the grid, by subranging the matrix:
  
  x(3:, 4: )
  
  The upper left angle of the sub matrix here starts at row 3 and column 4.

• Display of the StringList type, string, scalar, array and vector/matrix visualizers are now possible in the same window.

• Stepping with F8 through the code is snappy. Even with 10 visualizers displayed concurrently, there is no noticable delay.
• In case of matrices the chart generated from the matrix is a bitmap with a rainbow starting with dark blue at the minimum and ending with red hot at the maximum value. In case of 1D vectors and arrays the chart will show a simple line series. The picture shows how to draw the contents of a vector, display its data and how to compute dot product from two sections of the same vector:

Similar visualizers can be displayed for Matrices, TStrings (and derived classes), TStringList, 1D and 2D static and dynamic arrays. The displayed windows can be closed quickly by pressing the Escape key. Trial version of debugger visualizers is not available. All features are included with the release version of MtxVec only. Users manual can be downloaded here:

Dew Debugger Visualizer Users Manual