A Basic Introduction on Math-Link in Mathematica

Santanu K. Maiti

REVIEW

A Basic Introduction on Math-Link in Mathematica

Santanu K. Maiti

Mathematical Software · Submitted 1 Mar 2006 · 5 references

Pith's verdict: A beginner Mathematica tutorial that calls a Fortran program through a shell pipe but presents itself as MathLink; the central claim is mislabeled and unverified.

T0 · AI review

How this review was made: An AI referee (deepseek-v4-flash) read the paper on August 28, 2026 and answered a fixed list of questions about it. T0 is the starting level every paper gets. The levels describe how deeply Pith has checked the paper, never the authors.

T0 AI review An AI read the paper and answered a fixed list of questions.
T1 Audit Automatic checks that the references and files the paper relies on exist and match.
T2 Compute The paper's code or calculations re-run with the same results.
T3 Formal statement The claims written out in a formal math language a computer can read.
T4 Proof Those claims proved, and the proof checked by computer.

How Pith checks papers →

· 3 major objections · 5 minor · Ask about this paper · The compiled record · Read the full review →

Challenge this review Comment (0) Read on arXiv ↗

Cite ▾

arXiv IDcs/0603005 (version 4)

Pith IDIVCIFS5X, Pith's permanent record of this paper and its review

CitationSantanu K. Maiti. "A Basic Introduction on Math-Link in Mathematica." arXiv:cs/0603005 (2006). https://pith.science/paper/IVCIFS5X

Cite this reviewBibTeX for Pith's review of this paper

Claim paper

Why Pith says this

Highlight any text to comment on it.

Editor's note

read the letter

Quick take: this is a beginner's tutorial that mislabels a shell pipeline as MathLink. The Mathematica basics are fine, but the central claim — that you're learning MathLink — is wrong. The code uses ReadList["!mat < mat3.dat", ...], which just invokes the Fortran executable as a subprocess and reads its stdout. No MathLink API appears anywhere. So the title and abstract promise the wrong technology. If you read it as 'how to call a Fortran program from Mathematica via shell redirection,' the basic idea can work, though nothing here verifies it does. There are no printed outputs, no test runs; the exported data format is assumed to match the Fortran READ order, and the text even says 'ReadLeast' in one place. The Fortran code itself is standard; the Mathematica snippets are simple, sometimes with unstated assumptions (e.g., the 'If[i == j, t, 1.213]' inside a double loop constructs matrices with diagonal entries t/s and off-diagonals 1.213/2.079, but the code as typeset in the PDF is garbled by the typography). The exposition of notebooks and local/global variables is clear enough for a beginner, and the author is honest that the MathLink route for C already exists. The citation pattern is thin: five references, mostly textbooks, and no citation to actual MathLink documentation; the premise that MathLink 'will not work' for Fortran is unsupported and likely false, since MathLink is a protocol you can implement in any language. In short, this is a low-stakes tutorial with a load-bearing label error. It is not a research contribution; it has no data, no validation, and no new technique. The soft spots are not subtle misstatements — they are the core of the paper. I would not cite it, and I would not send it to a serious referee under its current framing. If a venue wanted a 'MathLink for beginners' article, the author needs to actually use MathLink or rename the paper. As is, treat it as an early draft, not a paper.

Referee report

Significance

If the paper actually demonstrated MathLink, it would fill a useful niche as a beginner-oriented introduction to coupling Fortran code with Mathematica. The paper does contain a genuinely simple walkthrough of notebook syntax and variable scoping, and it names the specific compiler flags and directory commands needed on an AIX system. However, as written, the central technical claim is false: the example uses a shell pipeline, not MathLink. The manuscript provides no outputs, no test case, and no verification that the data format matches the Fortran program's READ statements. Because the advertised content is the MathLink mechanism, and that mechanism is never implemented, the pedagogical value of the paper is substantially undermined even though the shell-piping trick might work in practice.

Major objections (3)

[Abstract; §3.1.2] The central claim that the example in Sec. 3.1.2 links an external program to Mathematica 'through proper mathlink commands' is not supported by the code. The only invocation of the external Fortran program is ReadList["!mat <mat3.dat", Number, RecordLists -> True], which uses Mathematica's shell-escape syntax to run the executable as a subprocess, redirecting the file mat3.dat to its standard input and then reading the program's standard output. No MathLink API functions (e.g., Install, LinkOpen, LinkWrite, LinkRead, LinkCreate, or LinkPatterns) appear anywhere in the notebook code, and the Fortran program is compiled as a standalone console executable with no MathLink stub. A beginner following this tutorial will not learn MathLink; the paper is mislabeled and the title/abstract promise the wrong technology.
[§3.1.2] The example is never verified. No output cells, no resulting eigenvalues, no sample matrices, and no timing or performance comparison are shown. The text even contains a typo in the key explanation: 'the command ReadLeast' should be 'ReadList'. For a tutorial whose stated purpose is to teach a working linking method, the absence of a single reproducible example means the reader cannot confirm that the procedure works or that the instructions are correct.
[§3.1.2; Fortran program in §3.1] The compatibility between the exported data file and the Fortran program's READ statements is not addressed. The Mathematica code builds mat3 = Partition[Flatten[{{mat1},{mat2}}], ns], which is a 2ns x ns matrix, and then inserts the one-element list {ns} as the first row, producing a file whose first record contains only the matrix order and whose next 2ns records contain the entries of the two matrices. The Fortran program reads n first and then reads n^2 entries for a and n^2 entries for b. While the counting is consistent, the paper never states this correspondence or shows that the Export/ReadList sequence actually works; an error in the ordering would silently produce wrong eigenvalues.

Minor objections (5)

[§2.2] The program as printed uses 'sample[times−]' with a minus sign instead of the Mathematica blank pattern 'times_'. As typeset, the code is not valid Mathematica syntax and will confuse beginners.
[§2.2.1] The explanation of local variables is misleading when it says their values are 'only defined within the cell.' In Mathematica, Block variables are scoped to the evaluation of the block, not to a notebook cell, and global variables assigned inside Block persist outside the cell. The paper should describe scope in terms of evaluation, not cells.
[§3.1.1] The compiler optimization flags are listed with lowercase letters ('-o', '-o0', '-o2'), which is inconsistent with the common IBM XL Fortran usage of uppercase '-O', '-O2', etc. The text later says '-o2' is the same as '-O', but the capitalization should be made consistent to avoid syntax errors.
[References] Reference [2] is not a complete citation and does not appear to document MathLink; it is listed as 'About Parallel Computing Toolkit' without publisher or year, and it does not support the sentence about linking C programs with Mathematica.
[Throughout] The manuscript repeatedly uses 'executive file' instead of 'executable file' and contains several typographical errors such as 'mathemtica' (Preface), 'algebric' (§2.1), and 'ylable' (Fig. 1). These should be corrected in a revision.

How Pith checks papers → · Full audit of this paper →

The paper

The paper claims

This paper shows that a Fortran-90 program can be linked into a Mathematica notebook using two commands, Export and ReadList with a shell redirect.

The reading

This is a tutorial paper whose central claim is that an external Fortran-90 program can be coupled to a Mathematica notebook using proper mathlink commands rather than a formal interface. The worked example constructs two square matrices in Mathematica, exports them to a data file, calls a compiled Fortran executable with ReadList["!mat True], and reads the product matrix back so that Eigenvalues can be computed in the notebook. The paper says this makes tedious numerical work fast, because compiled Fortran does the heavy loop while Mathematica keeps the analysis. It is aimed at beginners and also gives guidance on compilation and optimization flags for Fortran source files.

What carries the argument

The central mechanism is the command pair Export["mat3.dat", output] and ReadList["!mat <mat3.dat", Number, RecordLists -> True]. Export writes the matrix order followed by the two input matrices as plain text; the '!' prefix tells Mathematica to execute the external command 'mat' with the file redirected as its standard input; the Fortran program reads the order n, reads matrices a and b, computes c = matmul(a,b), and prints the result; ReadList parses those printed numbers back into a flat list, and Partition reassembles them into the product matrix. The work of carrying the data is done entirely by a text file and standard input/output, which is why no C-level MathLink programming is needed.

Extended reading notes

Core claim

The paper's discovery is that the Mathematica command ReadList["!mat <mat3.dat", Number, RecordLists -> True] completes a working bridge between a notebook and a separately compiled Fortran-90 executable. In the worked example, Mathematica builds two square matrices, inserts a leading row containing the matrix order, exports the result to mat3.dat, invokes the external program 'mat' through the '!' shell escape, and reads back the product matrix, which is then partitioned and passed to Eigenvalues. The article presents this as a general recipe: with the right compiler command, the same Export/ReadList pattern links Fortran 77 and Fortran 95 programs as well. The surrounding tutorial material on starting Mathematica, writing programs, and local versus global variables is preparation for this main mechanism.

Load-bearing premise

The load-bearing premise is that the numbers written to mat3.dat line up exactly with the Fortran program's READ(*) sequence: first the matrix order n, then all n×n entries of a, then all n×n entries of b; the paper never verifies this ordering against the file it actually exports.

Editorial extensions

If this is right

For a fixed compiled executable, changing the single parameter ns in the notebook cell regenerates the data file and produces eigenvalues for matrices of that order.
The same Export/ReadList recipe can be reused for other Fortran programs (F77 or F95) by compiling with the appropriate command, such as xlf, f77, or xlf95.
A user can keep the executable in a separate directory and connect to it with SetDirectory, then restore the original directory with ResetDirectory.
Because the bridge uses only a text file and standard input/output, no knowledge of the MathLink C API is required to use the example.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The described 'mathlink' is actually a text-file pipe: if a future version changes Mathematica's Export formatting or the Fortran READ order, the link breaks silently; a formal MathLink interface would not have that fragility.
The same stdin/stdout handoff should work for any compiled numerical program, not only Fortran, so the recipe generalizes to C, C++, or command-line programs that read numbers and print numbers.
A direct timing comparison between Mathematica's built-in matrix multiplication and the linked Fortran executable for large ns would make the speed claim testable; the paper reports no such measurement.

Original abstract

Starting from the basic ideas of mathematica, we give a detailed description about the way of linking of external programs with mathematica through proper mathlink commands. This article may be quite helpful for the beginners to start with and write programs in mathematica. In the first part, we illustrate how to use a mathemtica notebook and write a complete program in the notebook. Following with this, we also mention elaborately about the utility of the local and global variables those are very essential for writing a program in mathematica. All the commands needed for doing different mathematical operations can be found with some proper examples in the mathematica book written by Stephen Wolfram \cite{wolfram}. In the rest of this article, we concentrate our study on the most significant issue which is the process of linking of {\em external programs} with mathematica, so-called the mathlink operation. By using proper mathlink commands one can run very tedious jobs efficiently and the operations become extremely fast.

The compiled record

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. Numbers in the tables are the authors', checked by code. No sentence in this record was written by a model.

Compiled by classifier-1.13-20260917 via OpenRouter, question bank abstract-p1-20260923, 2026-09-23: 1 request, 5,555 input tokens, $0.0002 reported.

What the abstract itself states, as probabilities: claims first 0.03 · states limitation 0.12 · human participants 0.02 · controlled comparison 0.01 · randomized assignment 0.01 · states quantitative result 0.03 · compares with prior results 0.04 · mentions code or data availability 0.03.

The abstract, sentence by sentence

arXiv listing abstract v4. Results and the main claim are underlined; show every role.

Starting from the basic ideas of mathematica, we give a detailed description about the way of linking of external programs with mathematica through proper mathlink commands. This article may be quite helpful for the beginners to start with and write programs in mathematica. In the first part, we illustrate how to use a mathemtica notebook and write a complete program in the notebook. Following with this, we also mention elaborately about the utility of the local and global variables those are very essential for writing a program in mathematica. All the commands needed for doing different mathematical operations can be found with some proper examples in the mathematica book written by Stephen Wolfram \cite{wolfram}. In the rest of this article, we concentrate our study on the most significant issue which is the process of linking of {\em external programs} with mathematica, so-called the mathlink operation. By using proper mathlink commands one can run very tedious jobs efficiently and the operations become extremely fast.

background contribution method result interpretation main claim

What the classifier reports for each sentence. The number is the probability it gave the label.
#	sentence	role	the authors' own work	states the main conclusion	strength
s0	Starting from the basic ideas of mathematica, we give a detailed description about the way of linking of external programs with mathematica through proper mathlink commands.	contribution 0.88	0.55	0.12	asserted 0.99
s1	This article may be quite helpful for the beginners to start with and write programs in mathematica.	interpretation 0.71	0.07	0.08	hedged possibility 1.00
s2	In the first part, we illustrate how to use a mathemtica notebook and write a complete program in the notebook.	contribution 0.44	0.49	0.03	asserted 1.00
s3	Following with this, we also mention elaborately about the utility of the local and global variables those are very essential for writing a program in mathematica.	contribution 0.41	0.20	0.03	asserted 0.99
s4	All the commands needed for doing different mathematical operations can be found with some proper examples in the mathematica book written by Stephen Wolfram \cite{wolfram}.	background 1.00	0.04	0.03	asserted 0.96
s5	In the rest of this article, we concentrate our study on the most significant issue which is the process of linking of {\em external programs} with mathematica, so-called the mathlink operation.	contribution 0.90	0.27	0.13	asserted 0.96
s6	By using proper mathlink commands one can run very tedious jobs efficiently and the operations become extremely fast.	interpretation 0.36	0.14	0.39	asserted 0.62

What kind of paper the classifier reports this is: method or tool 0.76 · evidence from argument 0.62.

What was examined, and what was not

sources read

arXiv listing abstract v4

not examined

full text
figures and tables
references and citing sentences
relations to other papers

levels run

P abstract

not run

S sections
T body sentences
C citations
R cross-paper relations

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. Every number in the measurements table is the authors', checked by code. Record as JSON

Figures

**Figure 1.** A 2D plot for a set of two random numbers.

**Figure 2.** Schematic representation of mathlink operations

Figures reproduced from arXiv:cs/0603005 by the authors.

References

Works cited (5)

[1]

Stephen Wolfram. Mathematica-5.0. 13

View on Pith
[2]

Roman E. Maeder. About Parallel Computing Toolkit . A Wolfram Research Ap- plication Package

View on Pith
[3]

I. M. Smith. Programming in Fortran 90 : A First Course for Engineers and Scientists. University of Manchester, UK

View on Pith
[4]

Martin Counihan. Fortran 90. University of Southampton

View on Pith
[5]

IBM. XL Fortran for AIX : User’s Guide . 14

View on Pith

Discussion

Disagree with the review, or know something it missed? Leave a comment, highlight any passage above to comment on it, or challenge this review formally.

[1] [1]

Stephen Wolfram. Mathematica-5.0. 13

View on Pith

[2] [2]

Roman E. Maeder. About Parallel Computing Toolkit . A Wolfram Research Ap- plication Package

View on Pith

[3] [3]

I. M. Smith. Programming in Fortran 90 : A First Course for Engineers and Scientists. University of Manchester, UK

View on Pith

[4] [4]

Martin Counihan. Fortran 90. University of Southampton

View on Pith

[5] [5]

IBM. XL Fortran for AIX : User’s Guide . 14

View on Pith