Fortran Programming Tools under Linux
SciLab is one of my favorite programs running under Linux. If you deal with matrix or vector data, signal analysis, nonlinear optimization, plotting, or other mathematical manipulations, you owe it to yourself to explore this feature-packed program. (SciLab was reviewed in Linux Journal, Issue 11, and it is available for a variety of other computer platforms, including Sun Sparc station, IBM RS 6000, HP 9000, DEC Mips, and DEC Alpha.)
Beyond the hundreds of built-in or supplied mathematical functions, SciLab users can also dynamically link their own Fortran and C subroutines to the SciLab binary without recompiling the SciLab source code. The linked subroutines are then available for calling from within SciLab using either interactive commands or by executing scripts.
This important feature allows Fortran users (and C programmers) to make use of “tried and true” source code without the trouble of converting the subroutines to equivalent SciLab macros and scripts that use built-in SciLab functions. Just as important, tedious debugging can be kept to a minimum (provided the linked subroutines have already been tested thoroughly).
Returning once again to our original trivial example code, let's link the subroutine TRIG into a SciLab session. First, we need to compile the TRIG object module using the f77 command:
$ f77 -c trig.f
which produces trig.o in the present working directory. From within Scilab we link trig.o using the link command:
-->link('trig.o','trig') linking "trig_" defined in "trig.o " lastlink 0,0
The first argument string in the link command is the name (case sensitive) of the Fortran object module. If this module is not in the current SciLab working directory, you must include the path. The second argument string must be the exact name of the Fortran subroutine being linked; however, case is not important. (Note that SciLab variables are case-sensitive, so subsequent use of trig within SciLab requires that you use lower case.)
Other subroutines also can be linked in the same way, and SciLab lists all linked subroutines when the link command is issued without arguments, i.e.:
-->link() ans = trig
Now we are ready to use trig in our SciLab session, but first we need to specify the two input variables (n,x) for the trig subroutine. Below are the commands issued with Scilab echoing the results.
-->n=5 n = 5. -->x=[.1 .2 .3 .4 .5] x = ! .1 .2 .3 .4 .5 !
Actually calling trig is done using SciLab's fort command as illustrated below (along with the result) for our example:
-->y=fort('trig',n,1,'i',x,2,'r','out',[1,5],3,'r') y = ! .0903330 .1626567 .2189268 .2610349 .2907863 !
Okay, now for the explanation. On the left-hand side of the entered expression is a list of the subroutine output variables (y in this example). The arguments inside the fort expression consist of three groups. First is the called subroutine name (trig) as a string variable. This is followed by a list of the subroutine input variables, given in this example as:
The first three items are the input variable (n), its position in the trig subroutine argument list (1), and a string character representing the variable's type (i for integer). Likewise, the second input variable is the real array, x, positioned as the second argument in trig. This pattern continues until all the input variables are listed. Variables in the input list do not have to be listed in any particular order. In other words, we could have just as easily listed the inputs as:
Once all the input variables are listed, we can specify the output variable or variables, denoted in this example by:
The key word 'out' always appears, followed by a matrix notation informing SciLab that the output variable, y, is a 1x5 array. The 3 gives the position of y in the subroutine's argument list, and r states that the variable is type real.
Subroutines having more than one output variable simply need to list the parameters associated with each variable on the output side in the fort argument list and include each variable on the left-hand side of the expression. For example, assume we have a Fortran subroutine given by:
SUBROUTINE WIN95(IDEAS,BUGS,DOS,DELAY) REAL*4 BUGS(1,1), DOS, DELAY(1) INTEGER*2 IDEAS . . . RETURN END
The input variables are DOS and IDEAS, and the outputs are BUGS and DELAY. After compiling and linking this subroutine into SciLab, it is called by:
It's as easy as that!
When coupling Fortran subroutines with SciLab, any print statements within your Fortran subroutines will not print to the SciLab session. Instead they print to the X window from which you started SciLab (or on the console monitor if you loaded Scilab from a window manager, such as FVWM). More importantly, the dynamically linked Fortran subroutines can open, read, write, and close disk files. Subroutines containing COMMON blocks must be restructured to accept all the variables and constants through the fort command line.
- Download "Linux Management with Red Hat Satellite: Measuring Business Impact and ROI"
- Use Linux as a SAN Provider
- diff -u: What's New in Kernel Development
- Numerical Python
- NSA: Linux Journal is an "extremist forum" and its readers get flagged for extra surveillance
- RSS Feeds
- Tech Tip: Really Simple HTTP Server with Python
- Linux Systems Administrator
- Senior Perl Developer
- Technical Support Rep